阻塞队列例子(实现指定目录下查找包含关键字的文件)

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package blockingqueuetest;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.Scanner;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 *
 * @author Administrator
 */
public class BlockingQueueTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("Enter the 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_THREADES = 100;
        
        BlockingQueue<File> queue = new ArrayBlockingQueue<File>(FILE_QUEUE_SIZE); 
        //创建一个带有给定的（固定）容量和默认访问策略的 ArrayBlockingQueue
        
        FileEnumerationTask enumerator = new FileEnumerationTask(queue, new File(directory));
        new Thread(enumerator).start(); //该线程负责在指定目录下将所有文件加入阻塞队列
        for(int i = 1; i <= SEARCH_THREADES; i++)
        {
            new Thread(new SearchTask(queue, keyword)).start(); //该线程用来搜索指定文件是否包含关键字
            System.out.print(queue.size() + " ");
        }
        
    }
}
    
    
class FileEnumerationTask implements Runnable
{
    private BlockingQueue<File> queue;
    private File startingDirectory;
    public static File DUMMY = new File("");

    public FileEnumerationTask(BlockingQueue<File> queue, File startingDirectory) {
        this.queue = queue;
            this.startingDirectory = startingDirectory;
        }

        @Override
        public void run() {
            
            try
            {
                enumerate(startingDirectory);
                queue.put(DUMMY);
            }
            catch(InterruptedException e)
            {
            }
        }
        /*
         * 该函数的功能是遍历某个目录下(包括子目录)的文件，并将其加入到BlockingQueue中
         * 
        **/
        private void enumerate(File directory) throws InterruptedException
        {
            File[] files = directory.listFiles();
            for(File f: files)
            {
                if(f.isDirectory())
                    enumerate(f);
                else
                    queue.put(f);
            }
        }
}

/*
 * SearchTask的功能是提供一个方法，搜索指定目录下包含指定关键字的文件。
 */

class SearchTask implements Runnable
{

    private BlockingQueue<File> queue;
    private String keyword;

    public SearchTask(BlockingQueue<File> queue, String keyword) {
        this.queue = queue;
        this.keyword = keyword;
    }
    
    @Override
    public void run() {
        try {
            boolean done = false;
            while (!done) {
                File file = queue.take();
                if (file == FileEnumerationTask.DUMMY) {
                    queue.put(file);
                    done = true;
                } else {
                    try {
                        search(file);
                    } catch (FileNotFoundException ex) {
                    }
                }
            }
        } //        catch(IOException e)
//        {
//            e.printStackTrace();
//        }
        catch (InterruptedException e)
        {
        }
    }

    private void search(File file) throws FileNotFoundException {
        Scanner in = new Scanner(new FileInputStream(file));
        int lineNumber = 0;
        while(in.hasNext())
        {
            lineNumber++;
            String line = in.nextLine();
            if(line.contains(keyword))
                System.out.printf("%s:%d:%s%n", file.getPath(), lineNumber, line);
        }
        in.close();
    }
    
}