学习 Fork / Join框架

分支/合并框架的目的是以递归的形式将可以并行执行的任务拆分成更小的任务，然后将每一个任务的结果合并起来生成整体的结果，它是 ExecutorService 接口的一个实现，它把子任务分配给线程池（称为ForkJoinPool）中的工作线程。

1. 运行流程

2. 工作窃取算法

工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行。工作窃取的运行流程图如下：

那么为什么需要使用工作窃取算法呢？假如我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，于是把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如 A 线程负责处理 A 队列里的任务。但是有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

工作窃取算法的优点：充分利用线程进行并行计算，并减少了线程间的竞争

工作窃取算法的缺点：在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且消耗了更多的系统资源，比如创建多个线程和多个双端队列。

3. Fork/Join 如何处理任务

Fork/Join 使用两个类来完成分割任务和合并任务结果：

• ForkJoinTask：我们要使用 ForkJoin 框架，必须首先创建一个 ForkJoin 任务。它提供在任务中执行 fork() 和 join() 操作的机制，通常情况下我们不需要直接继承 ForkJoinTask 类，而只需要继承它的子类，Fork/Join 框架提供了以下两个子类：
  1. RecursiveAction：用于没有返回结果的任务。
  2. RecursiveTask ：用于有返回结果的任务。
• ForkJoinPool ：ForkJoinTask 需要通过 ForkJoinPool 来执行，任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。

4. ForkJoinPool实例化

ForkJoin 使用 ForkJoinPool 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。

在Java 8中，访问 ForkJoinPool 实例的最方便方法是使用其静态方法commonPool（）。顾名思义，这将提供对公共池的引用，公共池是每个ForkJoinTask的默认线程池。

使用预定义的公共池可以减少资源消耗，因为这会阻止为每个任务创建单独的线程池。

ForkJoinPool commonPool = ForkJoinPool.commonPool();

通过创建ForkJoinPool并将其分配给实用程序类的公共静态字段，可以在Java 7中实现相同的行为：

public static ForkJoinPool forkJoinPool = new ForkJoinPool(2);

现在可以轻松访问：

ForkJoinPool forkJoinPool = PoolUtil.forkJoinPool;

使用ForkJoinPool的构造函数，可以创建具有特定级别的并行性，线程工厂和异常处理程序的自定义线程池。在上面的示例中，池的并行度为2.这意味着池将使用2个处理器核心。

5. ForkJoinTask

ForkJoinTask是ForkJoinPool中执行的任务的基本类型。在实践中，它的两个子类之一应该被继承：RecursiveAction（空返回值任务）和 RecursiveTask （有返回值的任务）。 它们都有一个抽象方法compute（），其中定义了任务的逻辑。

6. 向线程池提交任务

6.1 submit() or execute()

forkJoinPool.execute(customRecursiveTask);
int result = customRecursiveTask.join();

6.2 invoke()

拆解任务并等待结果

int result = forkJoinPool.invoke(customRecursiveTask);

6.3 invokeAll()

invokeAll()是向ForkJoinPool提交大量ForkJoinTasks 的一种最方便的方式，它将任务作为参数，分解它们按照生成它们的顺序返回Future对象的集合。
或者 使用单独的 fork（）和 join（）方法。在fork（）的方法将ForkJoinTasks 提交到一个ForkJoinPool，但它不会触发它的执行。在join（）方法被调用之后才执行。在RecursiveAction的情况下，join（）只返回null ; 对于RecursiveTask ，它返回任务执行的结果：

customRecursiveTaskFirst.fork();
result = customRecursiveTaskLast.join();

例子1：用分支/合并框架实现并行求和

package streams;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
import java.util.function.Function;
import java.util.stream.LongStream;

/**
 * 继承RecursiveTask 来创建可以用于分支/合并框架的任务
 */
public class ForkJoinSum extends RecursiveTask {

    private final long[] numbers;
    private final int start;
    private final int end;

    public static final long SMALLSIZE = 10_000;
    public static final ForkJoinPool FORK_JOIN_POOL = new ForkJoinPool();

    public ForkJoinSum(long[] numbers) {
        this(numbers, 0, numbers.length);
    }

    private ForkJoinSum(long[] numbers, int start, int end) {
        this.numbers = numbers;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        int length = end - start;
        if (length < SMALLSIZE)
            return computeSequentailly();

        ForkJoinSum leftTask = new ForkJoinSum(numbers, start, start + length / 2);
        // 利用另一个ForkJoinPool线程异步执行新创建的子任务
        leftTask.fork();
        ForkJoinSum rightTask = new ForkJoinSum(numbers, start + length / 2, end);
        //同步执行第二个子任务，有可能允许进一步递归划分
        Long rightResult = rightTask.compute();
        //读取第一个子任务的结果，如果尚未完成就等待
        Long leftResult = (Long) leftTask.join();

        return leftResult + rightResult;
    }

    private long computeSequentailly() {
        long sum = 0;
        for (int i = start; i < end; i++) {
            sum +=numbers[i];
        }
        return sum;
    }

    public static long forkJoinSum(long n) {
        long[] nums = LongStream.rangeClosed(1,n).toArray();
        ForkJoinSum task = new ForkJoinSum(nums);
        return (long) FORK_JOIN_POOL.invoke(task);
    }

    public static long testPerf (Function<Long,Long> adder, long n) {
        long fast = Long.MAX_VALUE;
        for (int i = 0; i < 10; i++) {
            long start = System.nanoTime();
            adder.apply(n);
            long spendTime = (System.nanoTime() - start) / 1_000_000;

            if (spendTime < fast)
                fast = spendTime;
        }
        return fast;
    }

    public static void main(String[] args) {
       System.out.println("It spend " +
               testPerf(ForkJoinSum::forkJoinSum, 1_0000_000) + " ms");
    }
}

参考资料
Java 8 实战
聊聊并发（八）——Fork/Join 框架介绍