ForkJoinPool

ForkJoinPool是一种可以将任务分发执行后将结果汇总起来的线程池。它与ThreadPoolExector线程池的不同在于，ThreadPoolExector多个线程共用一个任务队列，而ForkJoinPool是不同的线程使用不同的任务队列。

如果有1000000个数，计算他们的和。如果一个线程跑，速度会比较慢，可以分成多个线程进行各自计算之后，把计算的和再汇总起来。

import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;

public class TestForkJoinPool {

    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);
        }
        long start = System.currentTimeMillis();
        int sum = Arrays.stream(nums).sum();
        long end = System.currentTimeMillis();
        System.out.println("单线程流方式计算结果："+sum+"  耗时："+(end-start));
    }

    /**
     * 继承RecursiveAction
     * 不带返回值，需要自行添加一个sum变量来进行汇总
     */
    static class AddTask extends RecursiveAction{
        int start, end;
        long sum;
        public AddTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        public long getSum() {
            return sum;
        }

        public void setSum(long sum) {
            this.sum = sum;
        }

        @Override
        protected void compute() {
            if (end-start <= max_num){
                long sum = 0L;
                for(int i = start;i<end;i++){
                    sum += nums[i];
                }
                setSum(sum);
            } else {
                int middle = start + (end-start)/2;
                AddTask subT1 = new AddTask(start, middle);
                AddTask subT2 = new AddTask(middle, end);
                subT1.fork();//异步执行任务
                subT2.fork();
                //需要join等待结果并且重新赋值
                subT1.join();
                subT2.join();
                setSum(subT1.getSum() + subT2.getSum());
            }
        }
    }

    /**
     * 继承RecursiveTask
     * 带返回值的，直接用jion获取
     */
    static class AddTaskRet extends RecursiveTask<Long> {
        int start, end;
        public AddTaskRet(int start, int end) {
            this.start = start;
            this.end = end;
        }
        @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 subT1 = new AddTaskRet(start, middle);
            AddTaskRet subT2 = new AddTaskRet(middle, end);
            subT1.fork();
            subT2.fork();
            return subT1.join() + subT2.join();
        }
    }


    public static void main(String[] args) throws IOException {
        ForkJoinPool fjp = new ForkJoinPool();
        AddTask addTask = new AddTask(0, nums.length);
        long start = System.currentTimeMillis();
        fjp.execute(addTask);
        addTask.join();
        long end = System.currentTimeMillis();
        System.out.println("不带返回值计算的和======="+addTask.getSum()+" 耗时："+(end-start));


        start = System.currentTimeMillis();
        AddTaskRet ret = new AddTaskRet(0, nums.length);
        fjp.execute(ret);
        Long join = ret.join();
        end = System.currentTimeMillis();
        System.out.println("带返回值的和================"+join+" 耗时："+(end-start));
    }
}

结果：

单线程流方式计算结果：49480567  耗时：106
不带返回值计算的和=======49480567 耗时：18
带返回值的和================49480567 耗时：12

可以看出多线程计算的方式可以快很多。