21、ThreadPool：线程池

一、线程通信

1. 同步代码块
2. 同步方法
3. 锁

二、线程池

public class Test {
    public static void main(String[] args) {
        //创建线程池
//        ExecutorService pool = Executors.newSingleThreadExecutor();
//        ExecutorService pool = Executors.newFixedThreadPool(5);
        ExecutorService pool = Executors.newCachedThreadPool();

        //执行任务
        for (int i = 0; i < 20; i++) {

            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"真哈皮");
                }
            };
            pool.execute(runnable);
        }
        //关闭线程池
        pool.shutdown();
    }
}

三、ForkJoin框架

public class SumTask extends RecursiveTask<Long> {
    private int start;
    private int end;
    private final int step = 2000000;//最小拆分成几个数相加
    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }
    @Override
    protected Long compute() {
        long sum = 0;
        if(end - start <= step ){
            //小于5个数，直接求和
            for (int i = start; i <=end; i++) {
                sum+=i;
            }
        }else{
          //大于5个数，分解任务
            int mid = (end + start)/2;
            SumTask leftTask = new SumTask(start,mid);
            SumTask rightTask = new SumTask(mid+1,end);
            //执行子任务
            leftTask.fork();
            rightTask.fork();
            //子任务，执行完，得到执行结果
            long leftSum = leftTask.join();
            long rightSum = rightTask.join();
            sum = leftSum+rightSum;
        }
        return sum;
    }
    public static void main(String[] args) 
throws ExecutionException, InterruptedException {
     //如果多核CPU，其实是一个一直使用，其他闲置；怎么办，多线程解决；
    //但是涉及到任务的拆分与合并等众多细节，不要紧，
//现在使用ForkJoin框架，可以较轻松解决；
        long  start = System.currentTimeMillis();
        long sum = 0;
        for(int i=0;i<=1000000000;i++){
            sum +=i;
        }
        System.out.println(sum);
        long end = System.currentTimeMillis();
        System.out.println("for:"+(end - start));
        //使用ForkJoin框架解决
        //创建一个线程池
        ForkJoinPool pool = new ForkJoinPool();
        //定义一个任务
        SumTask sumTask = new SumTask(1,1000000000);
        //将任务交给线程池
         start = System.currentTimeMillis();
        Future<Long> future = pool.submit(sumTask);
        //得到结果并输出
        Long result = future.get();
        System.out.println(result);
        end = System.currentTimeMillis();
        System.out.println("pool:"+(end - start));
    }
}

四、门闩类

1. CountDownLatch
2. CyclicBarrier
3. Semaphore