多线程 - 计算来自多个文件的字的总量

Question

我做了一个程序来计算单个文件的字数， ，但我怎样才能修改我的程序，因此它给出了所有文件（作为一个值）的字的总量。

我的代码如下所示：

public class WordCount implements Runnable 
{ 
    public WordCount(String filename) 
    { 
     this.filename = filename; 
    } 

    public void run() 
    { 
     int count = 0; 
     try 
     { 
     Scanner in = new Scanner(new File(filename)); 

     while (in.hasNext()) 
     { 
      in.next(); 
      count++; 
     } 
     System.out.println(filename + ": " + count); 
     } 
     catch (FileNotFoundException e) 
     { 
     System.out.println(filename + " blev ikke fundet."); 
     } 
    } 
    private String filename; 
} 

与主级：

public class Main 
{ 

    public static void main(String args[]) 
    { 
     for (String filename : args) 
     { 
     Runnable tester = new WordCount(filename); 

     Thread t = new Thread(tester); 
     t.start(); 
     } 
    } 
} 

，以及如何避免竞争条件？ 谢谢你的帮助。

Answer 1

您可以创建一个带有同步任务队列的线程池，该任务队列将包含您希望为其计算所有文件的所有文件。

当您的线程池工作人员联机时，他们可以要求任务队列计算一个文件。 工人完成他们的工作后，他们可以通知他们的最终号码的主线程。

主线程将有一个同步的通知方法，将所有工作线程的结果相加。

希望这会有所帮助。

Answer 2

您可以使用Future得到计数，并在末尾添加了所有的罪名，或者使用一个静态变量，并在​​方式增加它即使用明确地​​或者如果你的Runnable使用Atomic Increment

Answer 3

花了两个参数：

• 一个BlockingQueue<String>或BlockingQueue<File>输入文件的
• 的AtomicLong的

在一个循环中，您将从队列中获取下一个字符串/文件，计算其字数，并按该数量增加AtomicLong。循环是while(!queue.isEmpty())还是while(!done)取决于将文件送入队列的方式：如果您从头开始知道所有文件，则可以使用isEmpty版本，但是如果要从某个位置对其进行流式处理，则需要使用!done版本（并且done为volatile boolean或AtomicBoolean用于内存可见性）。

然后你把这些Runnable送到执行者那里，你应该很好走。

Answer 4

你可以使countvolatile和static所以所有的线程可以增加它。

public class WordCount implements Runnable 
{ 
    private static AtomicInteger count = new AtomicInteger(0); // <-- now all threads increment the same count 

    private String filename; 

    public WordCount(String filename) 
    { 
     this.filename = filename; 
    } 

    public static int getCount() 
    { 
     return count.get(); 
    } 

    public void run() 
    { 
     try 
     { 
     Scanner in = new Scanner(new File(filename)); 

     while (in.hasNext()) 
     { 
      in.next(); 
      count.incrementAndGet(); 
     } 
     System.out.println(filename + ": " + count); 
     } 
     catch (FileNotFoundException e) 
     { 
     System.out.println(filename + " blev ikke fundet."); 
     } 
    } 
} 

更新：有没有做过的java一段时间，但关于使其成为点私有静态字段仍然站立...只是使它成为AtomicInteger。

Answer 5

或者您可以让所有线程更新单个字数变量。如果计数是单词的话，count ++是原子的（一个int应该足够了）。

编辑︰原来的Java规格只是愚蠢的计数++是不是原子。我不知道为什么。无论如何，看看AtomicInteger及其incrementAndGet方法。希望这是原子（我不知道现在期待什么......），并且您不需要任何其他同步机制 - 只需将您的计数存储在AtomicInteger中。

Answer 6

您可以创建一些侦听器来从线程获取反馈。

public interface ResultListener { 
     public synchronized void result(int words); 
    } 
    private String filename; 
    private ResultListener listener; 
    public void run() 
    { 
    int count = 0; 
    try 
    { 
     Scanner in = new Scanner(new File(filename)); 

     while (in.hasNext()) 
     { 
      in.next(); 
      count++; 
     } 
     listener.result(count); 
    } 
    catch (FileNotFoundException e) 
    { 
     System.out.println(filename + " blev ikke fundet."); 
    } 
    } 
    } 

您可以像为您的文件名一样为侦听器添加一个构造器参数。

public class Main 
    { 
    private static int totalCount = 0; 
    private static ResultListener listener = new ResultListener(){ 
     public synchronized void result(int words){ 
      totalCount += words; 
     } 
    } 
    public static void main(String args[]) 
    { 
     for (String filename : args) 
     { 
      Runnable tester = new WordCount(filename, listener); 

      Thread t = new Thread(tester); 
      t.start(); 
     } 
    } 
    } 

Answer 7

工作线程：

class WordCount extends Thread 
{ 

    int count; 

    @Override 
    public void run() 
    { 
     count = 0; 
     /* Count the words... */ 
     ... 
     ++count; 
     ... 
    } 

} 

和A类使用它们：

class Main 
{ 

    public static void main(String args[]) throws InterruptedException 
    { 
     WordCount[] counters = new WordCount[args.length]; 
     for (int idx = 0; idx < args.length; ++idx) { 
     counters[idx] = new WordCount(args[idx]); 
     counters[idx].start(); 
     } 
     int total = 0; 
     for (WordCount counter : counters) { 
     counter.join(); 
     total += counter.count; 
     } 
     System.out.println("Total: " + total); 
    } 

} 

许多硬盘驱动器不这样做的同时读取多个文件的非常出色。参考地点对性能有很大影响。