java并发 fork/join

Fork/Join

把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架 ，使用工作窃取算法

工作窃取算法

工作窃取算法：某个线程从其他队列里窃取任务来执行

具体流程：

但是有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。
而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

• ForkJoinPool： 用来执行Task，或生成新的ForkJoinWorkerThread
• ForkJoinPool 的每个工作线程都维护着一个工作队列（WorkQueue）。这是一个双端队列，用来存放对象的任务。窃取任务从队尾窃取。
• ForkJoinTask：代表在Fork/join中执行的任务， 执行具体的分支逻辑，声明以同步/异步方式进行执行

fork():创建一个子任务，在当前运行的线程池中安排一个异步执行
join():当任务完成时返回计算结果
invoke():开始执行任务，如果必要，等待计算完成

子类：
RecursiveAction 一个递归无结果的ForkJoinTask（没有返回值）
RecursiveTask 一个递归有结果的ForkJoinTask（有返回值）

代码

使用Fork/Join框架首先要考虑到的是如何分割任务，如果希望每个子任务最多执行两个数的相加，那么我们设置分割的阈值是2，由于是4个数字相加
所以Fork/Join框架会把这个任务fork成两个子任务，子任务一负责计算1+2，子任务二负责计算3+4，然后再join两个子任务的结果。
因为是有结果的任务，所以必须继承RecursiveTask，实现代码如下：

public class CountTask extends RecursiveTask<Integer>{

    private static final int THREAD_HOLD = 2;

    private int start;
    private int end;

    public CountTask(int start,int end){
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        //如果任务足够小就计算
        boolean canCompute = (end - start) <= THREAD_HOLD;
        if(canCompute){
            for(int i=start;i<=end;i++){
                sum += i;
            }
        }else{
            int middle = (start + end) / 2;
            CountTask left = new CountTask(start,middle);
            CountTask right = new CountTask(middle+1,end);
            //执行子任务
            left.fork();
            right.fork();
            //获取子任务结果
            int lResult = left.join();
            int rResult = right.join();
            sum = lResult + rResult;
        }
        return sum;
    }

    public static void main(String[] args){
        ForkJoinPool pool = new ForkJoinPool();
        CountTask task = new CountTask(1,4);
        Future<Integer> result = pool.submit(task);
        try {
            System.out.println(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

ForkJoinTask与一般任务的主要区别在于它需要实现compute方法，在这个方法里，首先需要判断任务是否足够小，如果足够小就直接执行任务。如果不足够小，就必须分割成两个子任务，每个子任务在调用fork方法时，又会进入compute方法，看看当前子任务是否需要继续分割成子任务，如果不需要继续分割，则执行当前子任务并返回结果。使用join方法会等待子任务执行完并得到其结果。

执行子任务调用fork方法并不是最佳的选择，最佳的选择是invokeAll方法。

对于Fork/Join模式，假如Pool里面线程数量是固定的，那么调用子任务的fork方法相当于A先分工给B，然后A当监工不干活，B去完成A交代的任务。所以上面的模式相当于浪费了一个线程。那么如果使用invokeAll相当于A分工给B后，，A和B都去完成工作。这样可以更好的利用线程池，缩短执行的时间。

参考博客：
https://www.imooc.com/article/24822
https://www.cnblogs.com/cjsblog/p/9078341.html
https://www.cnblogs.com/senlinyang/p/7885964.html