分而治之的java类ForkJoin

Java 7开始引入了一种新的Fork/Join线程池，它可以执行一种特殊的任务：把一个大任务拆成多个小任务并行执行。

比如要计算一个超大数组的和，最简单的做法是用一个循环在一个线程内完成：

┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─
还有一种方法，可以把数组拆成两部分，分别计算，最后加起来就是最终结果，这样可以用两个线程并行执行：

┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘
如果拆成两部分还是很大，我们还可以继续拆，用4个线程并行执行：

┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
┌─┬─┬─┬─┬─┬─┐
└─┴─┴─┴─┴─┴─┘
这就是Fork/Join任务的原理：判断一个任务是否足够小，如果是，直接计算，否则，就分拆成几个小任务分别计算。这个过程可以反复“裂变”成一系列小任务。
1、ForkJoinPool
既然任务是被逐渐的细化的，那就需要把这些任务存在一个池子里面，这个池子就是ForkJoinPool，它与其它的ExecutorService区别主要在于它使用“工作窃取“，那什么是工作窃取呢？

一个大任务会被划分成无数个小任务，这些任务被分配到不同的队列，这些队列有些干活干的块，有些干得慢。于是干得快的，一看自己没任务需要执行了，就去隔壁的队列里面拿去任务执行。

2、ForkJoinTask
ForkJoinTask就是ForkJoinPool里面的每一个任务。他主要有两个子类：RecursiveAction和RecursiveTask。然后通过fork()方法去分配任务执行任务，通过join()方法汇总任务结果，
（1）RecursiveAction 一个递归无结果的ForkJoinTask（没有返回值）

（2）RecursiveTask 一个递归有结果的ForkJoinTask（有返回值）

ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成，ForkJoinTask数组负责存放程序提交给ForkJoinPool的任务，而ForkJoinWorkerThread数组负责执行这些任务。

RecursiveTask 案例

package com.concurrency3.forkjoin;

import java.util.concurrent.*;
import java.util.stream.IntStream;

/**
 * 
 */

public class ForkJoinRecursiveTask {

    private final static int MAX_THRESHOLD = 3;
//    RecursiveTask 一个递归有结果的ForkJoinTask（有返回值）
    private static class CalculatedRecursiveTask extends RecursiveTask<Integer>{

        private final int start;
        private final int end;

        private CalculatedRecursiveTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected Integer compute() {
            if(end - start<=MAX_THRESHOLD){// 如果任务足够小,直接计算:
                //rangeClosed包含结束节点，是闭合的
                return IntStream.rangeClosed(start,end).sum();
            }else {// 任务太大,一分为二:
                int middle = (start+end)/2;
                CalculatedRecursiveTask leftTask = new CalculatedRecursiveTask(start,middle);
                CalculatedRecursiveTask rightTask = new CalculatedRecursiveTask(middle+1,end);
                leftTask.fork();
                rightTask.fork();
                return leftTask.join()+rightTask.join();
            }
        }
    }

    public static void main(String[] args) {

        final ForkJoinPool forkJoinPool = new ForkJoinPool();
        Integer result = forkJoinPool.invoke(new CalculatedRecursiveTask(0, 100));
        System.out.println(result);
//        ForkJoinTask<V> implements Future<V>
        ForkJoinTask<Integer> future = forkJoinPool.submit(new CalculatedRecursiveTask(0, 100));
        try {
            Integer result1 = future.get();
            System.out.println(result1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

RecursiveAction 案例

package com.concurrency3.forkjoin;

import sun.print.SunMinMaxPage;

import java.util.Optional;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;

/**
 * @Author yxc
 */

public class ForkJoinRecursiveAction {

    private final static int MAX_THRESHOLD = 3;
    private final static AtomicInteger SUM = new AtomicInteger(0);

    private static class CalculateRecursiveAction extends RecursiveAction{

        private final int start;
        private final int end;

        private CalculateRecursiveAction(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected void compute() {
            if(end - start<=MAX_THRESHOLD){// 如果任务足够小,直接计算:
                //rangeClosed包含结束节点，是闭合的
                SUM.addAndGet(IntStream.rangeClosed(start,end).sum());
            }else {// 任务太大,一分为二:
                int middle=(start+end)/2;
                CalculateRecursiveAction leftAction = new CalculateRecursiveAction(start,middle);
                CalculateRecursiveAction rightAction = new CalculateRecursiveAction(middle+1,end);
                leftAction.fork();
                rightAction.fork();
            }
        }
    }

    public static void main(String[] args) {
        final ForkJoinPool forkJoinPool = new ForkJoinPool();
/*        forkJoinPool.invoke(new CalculateRecursiveAction(0, 100));
        try {
            forkJoinPool.awaitTermination(10000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(SUM);*/

        forkJoinPool.submit(new CalculateRecursiveAction(0,100));//没有返回值
        try {
            forkJoinPool.awaitTermination(10,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Optional.of(SUM).ifPresent(System.out::println);
    }

}

ForkJoinTask在执行的时候可能会抛出异常，在主线程中是无法直接获取的，但是可以通过ForkJoinTask提供的isCompletedAbnormally()方法来检查任务是否已经抛出异常或已经被取消了。

参考链接：https://www.liaoxuefeng.com/wiki/1252599548343744/1306581226487842
https://baijiahao.baidu.com/s?id=1649619201425234676&wfr=spider&for=pc