JAVA-初识线程池

通过查阅相关文献和Java核心技术，自己动手实现了Java的线程池，查找给定路径下包含给定单词的文件数量

线程池的相关概念：

https://www.cnblogs.com/CarpenterLee/p/9558026.html

package src;

import java.io.File;
import java.util.Scanner;

import java.util.concurrent.*;

public class ThreadPool {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        try {
            System.out.println("Enter a direction!");
            String dir = in.nextLine();
            System.out.println("Enter a  word");
            String word = in.nextLine();
            //新建一个不限线程数量的线程池
            ExecutorService pool = Executors.newCachedThreadPool();
            //新建一个MatchCount对象，参数包括文件路径，查询的单词，线程池对象
            MatchCount countTimes = new MatchCount(new File(dir), word, pool);
            //利用submit提交该任务，得到结果
            Future<Integer> result = pool.submit(countTimes);
            try {
                System.out.println(result.get() + "match Files");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            pool.shutdown();
            System.out.println("the max pool num:" + ((ThreadPoolExecutor) pool).getLargestPoolSize());
        } finally {
            in.close();
        }
    }
}

package src;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

//实现callable线程，可以有返回值
public class MatchCount implements Callable<Integer> {
    private File direction;
    private String keyWord;
    private ExecutorService pool;
    private int count;
    MatchCount(File direction, String keyWord, ExecutorService pool)
    {
        this.direction = direction;
        this.pool = pool;
        this.keyWord = keyWord;
    }
    //submit提交任务后调用call()函数
    @Override
    public Integer call() throws Exception {
        count = 0;
        try
        {
            File[] files = direction.listFiles();
            List<Future<Integer>> results = new ArrayList<>();
            for(File f : files)
            {
                if(f.isDirectory())
                {
                    MatchCount subMatchCount = new MatchCount(f,keyWord,pool);
                    //如果f是一个路径，则新建一个线程，并submit。
                    Future<Integer> result = pool.submit(subMatchCount);
                    //将线程的结果保存在results中
                    results.add(result);
                }
                else
                {
                    if(searcfKeyWord(f))
                    {
                        count += 1;
                    }
                }
            }
            //累加结果，进行汇总
            for(Future<Integer> res : results)
            {
                count +=res.get();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return count;
    }
    //判断当前文件中是否包含给定单词
    boolean searcfKeyWord(File f)
    {
        boolean hasWord = false;
        try(Scanner in = new Scanner(f,"UTF-8")) {
            while (!hasWord && in.hasNextLine())
            {
                String strLine = in.nextLine();
                if(strLine.contains(keyWord))hasWord = true;
            }
            return hasWord;
        } catch (FileNotFoundException e) {
            return hasWord;
        }
    }
}