Java中使用阻塞队列控制线程集实例

队列以一种先进先出的方式管理数据。如果你试图向一个已经满了的阻塞队列中添加一个元素，或是从一个空的阻塞队列中移除一个元素，将导致线程阻塞。在多线程进行合作时，阻塞队列是很有用的工具。工作者线程可以定期的把中间结果存到阻塞队列中。而其他工作者线程把中间结果取出并在将来修改它们。队列会自动平衡负载。如果第一个线程集运行的比第二个慢，则第二个线程集在等待结果时就会阻塞。如果第一个线程集运行的快，那么它将等待第二个线程集赶上来。

下面的程序展示了如何使用阻塞队列来控制线程集。程序在一个目录及它的所有子目录下搜索所有文件，打印出包含指定关键字的文件列表。

java.util.concurrent包提供了阻塞队列的4个变种：linkedblockingqueue、arrayblockingqueue、priorityblockingqueue和delayqueue。我们用的是arrayblockingqueue。arrayblockingqueue在构造时需要给定容量，并可以选择是否需要公平性。如果公平参数被设置了，等待时间最长的线程会优先得到处理。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。

生产者线程枚举在所有子目录下的所有文件并把它们放到一个阻塞队列中。这个操作很快，如果队列没有设上限的话，很快它就包含了没有找到的文件。

我们同时还启动了大量的搜索线程。每个搜索线程从队列中取出一个文件，打开它，打印出包含关键字的所有行，然后取出下一个文件。我们使用了一个小技巧来在工作结束后终止线程。为了发出完成信号，枚举线程把一个虚拟对象放入队列。（这类似于在行李输送带上放一个写着“最后一个包”的虚拟包。）当搜索线程取到这个虚拟对象时，就将其放回并终止。

注意，这里不需要人任何显示的线程同步。在这个程序中，我们使用队列数据结构作为一种同步机制。

import java.io.*; 
import java.util.*; 
import java.util.concurrent.*; 

public class blockingqueuetest 
{ 
   public static void main(string[] args) 
   { 
      scanner in = new scanner(system.in); 
      system.out.print("enter base directory (e.g. /usr/local/jdk1.6.0/src): "); 
      string directory = in.nextline(); 
      system.out.print("enter keyword (e.g. volatile): "); 
      string keyword = in.nextline(); 

      final int file_queue_size = 10; 
      final int search_threads = 100; 

      blockingqueue<file> queue = new arrayblockingqueue<file>(file_queue_size); 

      fileenumerationtask enumerator = new fileenumerationtask(queue, new file(directory)); 
      new thread(enumerator).start(); 
      for (int i = 1; i <= search_threads; i++) 
         new thread(new searchtask(queue, keyword)).start(); 
   } 
} 

/** 
 * this task enumerates all files in a directory and its subdirectories. 
 */
class fileenumerationtask implements runnable 
{ 
   /** 
    * constructs a fileenumerationtask. 
    * @param queue the blocking queue to which the enumerated files are added 
    * @param startingdirectory the directory in which to start the enumeration 
    */
   public fileenumerationtask(blockingqueue<file> queue, file startingdirectory) 
   { 
      this.queue = queue; 
      this.startingdirectory = startingdirectory; 
   } 

   public void run() 
   { 
      try
      { 
         enumerate(startingdirectory); 
         queue.put(dummy); 
      } 
      catch (interruptedexception e) 
      { 
      } 
   } 

   /** 
    * recursively enumerates all files in a given directory and its subdirectories 
    * @param directory the directory in which to start 
    */
   public void enumerate(file directory) throws interruptedexception 
   { 
      file[] files = directory.listfiles(); 
      for (file file : files) 
      { 
         if (file.isdirectory()) enumerate(file); 
         else queue.put(file); 
      } 
   } 

   public static file dummy = new file(""); 

   private blockingqueue<file> queue; 
   private file startingdirectory; 
} 

/** 
 * this task searches files for a given keyword. 
 */
class searchtask implements runnable 
{ 
   /** 
    * constructs a searchtask. 
    * @param queue the queue from which to take files 
    * @param keyword the keyword to look for 
    */
   public searchtask(blockingqueue<file> queue, string keyword) 
   { 
      this.queue = queue; 
      this.keyword = keyword; 
   } 

   public void run() 
   { 
      try
      { 
         boolean done = false; 
         while (!done) 
         { 
            file file = queue.take(); 
            if (file == fileenumerationtask.dummy) 
            { 
               queue.put(file); 
               done = true; 
            } 
            else search(file);             
         } 
      } 
      catch (ioexception e) 
      { 
         e.printstacktrace(); 
      } 
      catch (interruptedexception e) 
      { 
      }       
   } 

   /** 
    * searches a file for a given keyword and prints all matching lines. 
    * @param file the file to search 
    */
   public void search(file file) throws ioexception 
   { 
      scanner in = new scanner(new fileinputstream(file)); 
      int linenumber = 0; 
      while (in.hasnextline()) 
      { 
         linenumber++; 
         string line = in.nextline().trim(); 
         if (line.contains(keyword)) system.out.printf("%s:%d    %s%n", file.getpath(), linenumber, line); 
      } 
      in.close(); 
   } 

   private blockingqueue<file> queue; 
   private string keyword; 
}