JDK 5のCallableとFutureの応用:スレッドの実行結果を取得する

public FutureTask(Callable callable) {
       if (callable == null)
           throw new NullPointerException();
       this.callable = callable;
       this.state = NEW;       // ensure visibility of callable
}

public FutureTask(Runnable runnable, V result) {
       this.callable = Executors.callable(runnable, result);
       this.state = NEW;       // ensure visibility of callable
}

package chapter14;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

/**
 *                          
 */
public class FutureTest {

	public static void main(String[] args) {
		//Scanner in = new Scanner(System.in);
		//System.out.println("Enter base directory (e.g. /usr/local/jdk/src)");
		//String directory = in.nextLine();
		//System.out.println("Enter keyword (e.g volatile)");
		//String keyword = in.nextLine();
		
		String directory = "D:\\test";
		String keyword = "jdbc";
		
		MatchCounter counter = new MatchCounter(new File(directory), keyword);
		FutureTask task = new FutureTask(counter);
		Thread t = new Thread(task);
		t.start();//    ,  call()    
		
		try {
			System.out.println(task.get() + " matching files.");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		
	}
	
}

class MatchCounter implements Callable {
	
	private File directory;//      
	private String keyword;//       
	private int count;//  
	
	public MatchCounter(File directory, String keyword) {
		this.directory = directory;
		this.keyword = keyword;
	}

	public Integer call() throws Exception {
		count = 0;
		File[] files = directory.listFiles();//             
		List> results = new ArrayList>();
		
		//       
		for(File file : files) {
			if(file.isDirectory()) {
				MatchCounter counter = new MatchCounter(file, keyword);
				// Callable     Future  Runnable   
				FutureTask task = new FutureTask(counter);
				results.add(task);
				Thread t = new Thread(task);
				t.start();
			}else { 
				if(search(file)) {
					count ++;
				}
			}
		}
		
		for(Future result:results) {
			count += result.get();
		}
		//    
		return count;
	}
	
	/**
	 *             
	 * @param file
	 * @return
	 */
	public boolean search(File file) {
		InputStream is = null;
		Scanner in = null;
		try{
			is = new FileInputStream(file);
			in = new Scanner(is);
			boolean found = false;
			while(!found && in.hasNextLine()) {
				//    
				String line = in.nextLine();
				//       ,     
				if(line.contains(keyword)) {
					found = true;
				}
			}
			return found;
		} catch (FileNotFoundException e) {
			return false;
		} finally{
			try {
				if(is != null) {
					is.close();
				}
				if(in != null) {
					in.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
}

package tradition;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 *   Callable      
 */
public class CallableAndFuture {

	public static void main(String[] args) {
		//            
		ExecutorService threadPool = 
				Executors.newSingleThreadExecutor();
		//  Callable          
		Future future = 
		threadPool.submit(
			new Callable() {
				@Override
				public String call() throws Exception {
					Thread.sleep(2000);
					return "hello";
				}
				
			}
		);
		System.out.println("    ：");
		try {
			System.out.println("    ：" + future.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
		
		//              
		ExecutorService threadPool2 = Executors.newFixedThreadPool(10);
		//     ExecutorCompletionService,            
		CompletionService completionService = 
				new ExecutorCompletionService<>(threadPool2);
		//  10   
		for(int i = 1; i <= 10; i ++) {
			final int seq = i;
			completionService.submit(new Callable(){
				@Override
				public Integer call() throws Exception {
					Thread.sleep(new Random().nextInt(5000));
					return seq;
				}
			});
		}
		
		for(int i = 0; i < 10; i ++) {
			//      
			try {
				System.out.println(completionService.take().get());
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			}
		}
	}
	
}