• ThreadPoolExecutor

ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,//线程的空闲存活时间（核心线程一般不会回收）
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) 

1. 当有任务进入线程池时，如果核心线程数没满，则创建去运行，
2. 当核心线程数满了，会放入等待队列等待，
3. 这时候，如果等待队列满了，又有新的任务要执行，就会再去创建线程执行，但不会超过maximumPoolSize，
4. 当线程执行数量达到maximumPoolSize，等待队列也满的时候，再有任务进来就会执行拒绝策略。

• ForkJoinPool

-分解汇总的任务
-用很少的线程可以执行很多的任务（子任务），ThreadPoolExecutor做不到先执行子任务
-CPU密集型

计算一个大容量数组的和：

public class ForkJoinPoolTest {
    static int[] nums = new int[1000000];
    static final int MAX_NUM = 50000;
    static Random r = new Random();
    
    static {
          //初始化数组
        for(int i=0; i<nums.length; i++) {
            nums[i] = r.nextInt(100);
        }
        
        System.out.println("---" + Arrays.stream(nums).sum()); //stream api
    }
    
     //没有返回值的方式
    static class AddTask extends RecursiveAction {

        int start, end;

        AddTask(int s, int e) {
            start = s;
            end = e;
        }

        @Override
        protected void compute() {

            if(end-start <= MAX_NUM) {
                long sum = 0L;
                for(int i=start; i<end; i++) sum += nums[i];
                System.out.println("from:" + start + " to:" + end + " = " + sum);
            } else {

                int middle = start + (end-start)/2;

                AddTask subTask1 = new AddTask(start, middle);
                AddTask subTask2 = new AddTask(middle, end);
                subTask1.fork();
                subTask2.fork();
            }


        }

    }

    //这个可以得到返回值
    static class AddTaskRet extends RecursiveTask<Long> {
        
        private static final long serialVersionUID = 1L;
        int start, end;
        
        AddTaskRet(int s, int e) {
            start = s;
            end = e;
        }

        @Override
        protected Long compute() {
            
            if(end-start <= MAX_NUM) {
                long sum = 0L;
                for(int i=start; i<end; i++) sum += nums[i];
                return sum;
            } 
            
            int middle = start + (end-start)/2;
            
            AddTaskRet subTask1 = new AddTaskRet(start, middle);
            AddTaskRet subTask2 = new AddTaskRet(middle, end);
            subTask1.fork();
            subTask2.fork();
            
            return subTask1.join() + subTask2.join();
        }
        
    }
    
    public static void main(String[] args) throws IOException {
        /*ForkJoinPool fjp = new ForkJoinPool();
        AddTask task = new AddTask(0, nums.length);
        fjp.execute(task);*/

        ForkJoinPool fjp = new ForkJoinPool();
        AddTaskRet task = new AddTaskRet(0, nums.length);
  //    fjp.execute(task);
//      long result = task.join();
        long result = fjp.invoke(task);
        System.out.println(result);
                
    }
}