队列阻塞浅析

  这几天所做的项目中涉及到了队列阻塞机制，通过研究整理如下。在这里和大家分享。

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

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

 

　 　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;
 }