线程池例子(实现统计指定目录下面包含关键字文件的多少)

package threadpooltest;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

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

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner in = new Scanner(System.in);
        System.out.print("Enter base directory (e.g. /usr/local/jdk5.0/src) :");
        String directory = in.nextLine();
        System.out.print("Enter keyword (e.g. volatile)");
        String keyword = in.nextLine();
        
        ExecutorService pool = Executors.newCachedThreadPool(); //如果有空闲线程就执行，没有就新建
        
        MatchCounter counter = new MatchCounter(new File(directory), keyword, pool);
        Future<Integer> result = pool.submit(counter);
        
        try
        {
            System.out.println(result.get() + "matching files");
        }
        catch(ExecutionException e)
        {
            e.printStackTrace();
        }
        catch(InterruptedException e)
        {
        }
        pool.shutdown();
        
        int largestPoolSize = ((ThreadPoolExecutor) pool).getLargestPoolSize();
        System.out.println("largest pool size= " + largestPoolSize);           
     }
}

/*
 * MatchCounter类实现了call方法。该方法查找指定目录下的文件及子目录。如果文件包含关键字则count++.
 * 如果是目录则递归将执行结果存入类型为Feture<Integer>的ArrayList数组。最后将count的值加上递归得
 * 到的值。算出指定目录下面包含关键字的文件的数目。
 */

class MatchCounter implements Callable<Integer>
{
    private File directory;
    private String keyword;
    private ExecutorService pool;
    private int count;

    public MatchCounter(File directory, String keyword, ExecutorService pool) {
        this.directory = directory;
        this.keyword = keyword;
        this.pool = pool;
    }
    
    @Override
    public Integer call()
    {
        count = 0;
        try
        {
            File[] files = directory.listFiles();
            ArrayList<Future<Integer>> results = new ArrayList<Future<Integer>>();
            
            for(File file: files)
            {
                if(file.isDirectory())
                {
                    MatchCounter counter = new MatchCounter(file, keyword, pool);
                    Future<Integer> result = pool.submit(counter);
                    results.add(result);
                }
                else
                {
                    if(search(file))
                        count++;
                }
            }
            for(Future<Integer> result: results)
            {
                try
                {
                    count += result.get();
                }
                catch(ExecutionException e)
                {
                }
            }
        }
        catch(InterruptedException e)
        {
        }
        return count;
    }

    private boolean search(File file) {
        try
        {
            Scanner in = new Scanner(new FileInputStream(file));
            boolean found = false;
            while(!found && in.hasNextLine())
            {
                String line = in.nextLine();
                if (line.contains(keyword))
                    found = true;
            }
            in.close();
            return found;
        }
        catch(IOException e)
        {
            return false;
        }
    }
    
}