java多线程（3）----阻塞队列

阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列。

package blockingQueue;

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

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_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();
		}
			
	}
}

package blockingQueue;

import java.io.File;
import java.util.concurrent.BlockingQueue;

public class FileEnumerationTask implements Runnable{
	
	public static File DUMMY = new File("");
	private BlockingQueue<File> queue;
	private File startingDirectory;
	
	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){
			
		}
	}
	private void enumerate(File directory) throws InterruptedException{
		File[] files = directory.listFiles();
		for(File file:files){
			if(file.isDirectory())//如果是文件夹，继续向下搜索
				enumerate(file);
			else {
				queue.put(file);//将指定的元素插入此队列的尾部，如果该队列已满，则阻塞等待可用的空间。 
			}
		}
		
	}
}

package blockingQueue;

import java.io.File;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.BlockingQueue;

public class SearchTask implements Runnable{

	private BlockingQueue<File> queue;
	private String keyword;
	
	public SearchTask(BlockingQueue<File> queue, String keyword) {
		this.keyword = keyword;
		this.queue = queue;
	}

	@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 (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
		}
		catch(InterruptedException e){
			
		}
	}
/*
 * 找到关键字所在行
 */
	private void search(File file) throws IOException{
		// TODO Auto-generated method stub
		try (Scanner in = new Scanner(file)){
			int lineNumber = 0;
			while (in.hasNextLine()){
				lineNumber++;
				String line = in.nextLine();
				if(line.contains(keyword))
					System.out.printf("%s:%d:%s%n",file.getPath(),lineNumber,line);
			}
		}
	}
}