【二十】Java多线程J.U.C之Fork/Join框架

JDK1.7引入的Fork/Join框架是基于工作窃取算法

工作窃取算法

工作窃取(work-stealing)算法是指某个线程从其他队列里窃取任务来执行。
一个大任务分割为若干个互不依赖的子任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应。

比如线程1负责处理队列A里的任务，线程2负责队列B的。

如果线程1把自己的队列A里的任务完成后，线程2负责的队列B还有很多任务待处理。

那么线程1会去窃取线程2的队列B中的任务来执行。

这时它们可能会访问同一个队列，所以为了减少窃取任务线程（线程1）和被窃取任务线程（线程2）之间的竞争，通常会使用双端队列，被窃取任务线程（线程2）永远从双端队列（队列B）的头部拿任务执行，而窃取任务线程（线程1）永远从双端队列（队列B）的尾部拿任务执行。

Fork/Join框架简介

Fork 就是把一个大任务切分为若干子任务并行的执行，Join 就是合并这些子任务的执行结果，最后得到这个大任务的结果。

核心类

ForkJoinPool：用来执行Task，或生成新的ForkJoinWorkerThread，执行工作线程间的工作窃取算法逻辑。

ForkJoinTask：工作任务，主要提供在任务中执行Fork和Join操作的机制。可以选择同步/异步方式进行执行。保存在工作队列（ForkJoinPool.WorkQueue）中。

ForkJoinWorkerThread：是 ForkJoinPool 内的工作线程，执行工作任务。每个工作线程都维护着一个工作队列（双端队列）

代码演示

计算从1+2+3+4一直加到100。

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

@Slf4j
//继承RecursiveTask类，结果返回Integer类型的值
public class ForkJoinTaskExample extends RecursiveTask<Integer> {

    public static final int threshold = 2;
    private int start;
    private int end;

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

    //重写RecursiveTask中的compute（）方法，该方法中真正做fork和join操作
    @Override
    protected Integer compute() {
        int sum = 0;

        //如果任务足够小就计算任务
        boolean canCompute = (end - start) <= threshold;
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            // 如果任务大于阈值，就分裂成两个子任务计算
            int middle = (start + end) / 2;
            ForkJoinTaskExample leftTask = new ForkJoinTaskExample(start, middle);
            ForkJoinTaskExample rightTask = new ForkJoinTaskExample(middle + 1, end);

            // 执行子任务
            invokeAll(leftTask, rightTask);

            // 等待任务执行结束合并其结果
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();

            // 合并子任务
            sum = leftResult + rightResult;
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkjoinPool = new ForkJoinPool();

        //生成一个计算任务，计算1+2+3+4
        ForkJoinTaskExample task = new ForkJoinTaskExample(1, 100);

        //执行一个任务  执行compute()方法
        Future<Integer> result = forkjoinPool.submit(task);

        try {
            log.info("result:{}", result.get());
        } catch (Exception e) {
            log.error("exception", e);
        }
    }
}

1.ForkJoinPool 使用submit 或 invoke 提交的区别：

invoke是同步执行，调用之后需要等待任务完成，才能执行后面的代码。

submit是异步执行，只有在Future调用get的时候会阻塞。

2.继承RecursiveTask，适用于有返回值的场景。

继承RecursiveAction，适合于没有返回值的场景。

3.ForkJoinTask 在执行的时候可能会抛出异常，ForkJoinTask 提供了 isCompletedAbnormally() 方法来检查任务是否已经抛出异常或已经被取消了，并且可以通过 ForkJoinTask 的 getException 方法获取异常。

4.leftTask.fork();rightTask.fork()和invokeAll(leftTask,rightTask)的区别

调用xxxTask.fork()的线程自己会变成监工，不干活。这样线程的利用率太低了。

而invokeAll的N个任务中，其中N-1个任务会使用fork()交给其它线程执行，它会留一个任务自己执行，这样充分利用了线程池，保证没有空闲的不干活的线程。