单线程，多线程，线程池方法大文件指定单词数量统计

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class test {

    private static BufferedReader reader;
    private static int Count = 0;
    private static int threadNum;
    private static String word;
    private static String way;
    private static long beginTime;
    private static long endTime;



    private static final int Single = 0;
    private static final int Multi = 1;
    private static final int Pool = 2;
    private static final int Failed = 3;


    @Override
    protected void finalize() throws Throwable {
        super.finalize();
    }

    public static void main(String[] args) {

        beginTime=System.currentTimeMillis();
        try {
            File file = new File("test.txt");
            reader = new BufferedReader(new FileReader(file));
        } catch (Exception e) {
            e.printStackTrace();
        }

        if (judgeThread(args) == Single) {
            if (args.length == 3) {
                word = args[2];
            } else {
                word = args[4];
            }
            threadNum = 1;
            search();
            print();
        } else if (judgeThread(args) == Multi) {
            word = args[4];
            threadNum = Integer.valueOf(args[3]);
            multiSearch();
        } else if (judgeThread(args) == Pool) {
            word = args[4];
            threadNum = Integer.valueOf(args[3]);
            poolSearch();
        }
        else {
            System.out.println("Error Input!");
        }
    }

    private static void search() {
        try {
            String line;
            while ((line = reader.readLine()) != null) {
                String content[] = line.split(" ");
                for (int i=1;i<content.length;i++) {
                    if (content[i].equals(word)) {
                        Count++;
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static int judgeThread(String[] args) {
        if ((args.length == 3 && args[0].equals("-t") && args[1].equals("Single"))
                || args.length == 5 && args[0].equals("-t") && args[1].equals("Single") && args[2].equals("-n")) {
            way=args[1];
            return Single;
        } else if (args.length == 5 && args[0].equals("-t") && args[1].equals("Multi") && args[2].equals("-n")) {
            way=args[1];
            return Multi;
        } else if (args.length == 5 && args[0].equals("-t") && args[1].equals("Pool") && args[2].equals("-n")) {
            way=args[1];
            return Pool;
        }
        return Failed;
    }

    private static void multiSearch() {
        CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        Lock lock = new ReentrantLock();
        for (int i = 0; i < threadNum; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    search();
                    countDownLatch.countDown();
                    lock.unlock();
                }
            }).start();
        }
        try {
            countDownLatch.await();
        } catch (Exception e) {
            e.printStackTrace();
        }
        print();
    }

    private static void poolSearch() {
        ExecutorService pool= Executors.newCachedThreadPool();
        Lock lock=new ReentrantLock();
        for(int i=0;i<threadNum;i++) {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    lock.lock();
                    search();
                    lock.unlock();
                }
            });
        }
        pool.shutdown();
        try {
            while(!pool.awaitTermination(1, TimeUnit.SECONDS));
        } catch (Exception e) {
            e.printStackTrace();
        }
        print();
    }

    private static void print() {
        endTime=System.currentTimeMillis();
        System.out.println("单词"+word+"共有"+Count+"个");
        System.out.println("运行方式为："+way);
        System.out.println("线程数为:"+threadNum+"共耗时"+(double)(endTime-beginTime)/1000+"s");
        }
}