一个实用的二分法工具类ForkJoinPool

工具类

ForkJoinPoolUtil

package zk;

import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * @author wwy
 * @date 2021/6/4 10:15
 */
public class ForkJoinPoolUtil<T> extends RecursiveAction {

    //二分开始位置
    private Integer start;

    //二分结束位置
    private Integer end;

    //判断达到该步长则开始执行任务
    private Integer sign;

    //执行任务的消费方法函数体
    private Consumer<List<T>> consumer;

    //消费的数据
    private List<T> data;

    /**
     * @param start    二分开始位置
     * @param end      二分结束位置
     * @param sign     判断达到该步长则开始执行任务
     * @param consumer 执行任务的消费方法函数体
     * @param data     消费的数据
     * @param <T>
     * @return
     */
    public static <T> ForkJoinPoolUtil getInstance(Integer start, Integer end, Integer sign, Consumer<List<T>> consumer, List<T> data) {
        return new ForkJoinPoolUtil(start, end, sign, consumer, data);
    }

    private ForkJoinPoolUtil(Integer start, Integer end, Integer sign, Consumer<List<T>> consumer, List<T> data) {
        this.start = start;
        this.end = end;
        this.sign = sign;
        this.consumer = consumer;
        this.data = data;
    }

    @Override
    protected void compute() {
        System.out.println("compute start ----" + Thread.currentThread().getName() + "                    " + "start：" + start + " end：" + end);
        if (end - start <= sign) {
            consumer.accept(data.subList(start, end));
        } else {
            int middle = (end + start) / 2;
            ForkJoinPoolUtil taskLeft = new ForkJoinPoolUtil(start, middle, sign, consumer, data);
            ForkJoinPoolUtil taskRight = new ForkJoinPoolUtil(middle, end, sign, consumer, data);
            invokeAll(taskLeft, taskRight);
        }
        System.out.println("compute end ----" + Thread.currentThread().getName() + "                    " + "start：" + start + " end：" + end);
    }

    public static void main(String[] args) {
        Consumer<List<Integer>> consumer;
        int sign = 2;

        consumer = list -> list.stream().map(e -> Thread.currentThread().getName() + "----------(" + e + ")----------").forEach(System.out::println);

        List<Integer> voList = IntStream.range(0, 10).boxed().map(e -> e.intValue()).collect(Collectors.toList());

        ForkJoinPool pool = new ForkJoinPool(3);
        ForkJoinPoolUtil<List<Integer>> poolUtil = ForkJoinPoolUtil.getInstance(0, voList.size(), sign, consumer, voList);
        pool.invoke(poolUtil);
        try {
            poolUtil.get();
        } catch (ExecutionException | InterruptedException e) {
            System.err.println("线程中断: " + e);
        }
    }
}

main方法执行结果：

compute start ----ForkJoinPool-1-worker-3                    start：0 end：10
compute start ----ForkJoinPool-1-worker-3                    start：0 end：5
compute start ----ForkJoinPool-1-worker-3                    start：0 end：2
compute start ----ForkJoinPool-1-worker-5                    start：5 end：10
compute start ----ForkJoinPool-1-worker-5                    start：5 end：7
compute start ----ForkJoinPool-1-worker-7                    start：2 end：5
compute start ----ForkJoinPool-1-worker-7                    start：2 end：3
ForkJoinPool-1-worker-5----------(5)----------
ForkJoinPool-1-worker-7----------(2)----------
ForkJoinPool-1-worker-3----------(0)----------
ForkJoinPool-1-worker-5----------(6)----------
ForkJoinPool-1-worker-3----------(1)----------
compute end ----ForkJoinPool-1-worker-5                    start：5 end：7
compute end ----ForkJoinPool-1-worker-7                    start：2 end：3
compute end ----ForkJoinPool-1-worker-3                    start：0 end：2
compute start ----ForkJoinPool-1-worker-5                    start：7 end：10
compute start ----ForkJoinPool-1-worker-7                    start：3 end：5
compute start ----ForkJoinPool-1-worker-5                    start：7 end：8
ForkJoinPool-1-worker-7----------(3)----------
ForkJoinPool-1-worker-5----------(7)----------
ForkJoinPool-1-worker-7----------(4)----------
compute end ----ForkJoinPool-1-worker-5                    start：7 end：8
compute end ----ForkJoinPool-1-worker-7                    start：3 end：5
compute start ----ForkJoinPool-1-worker-5                    start：8 end：10
compute end ----ForkJoinPool-1-worker-7                    start：2 end：5
ForkJoinPool-1-worker-5----------(8)----------
ForkJoinPool-1-worker-5----------(9)----------
compute end ----ForkJoinPool-1-worker-5                    start：8 end：10
compute end ----ForkJoinPool-1-worker-5                    start：7 end：10
compute end ----ForkJoinPool-1-worker-5                    start：5 end：10
compute end ----ForkJoinPool-1-worker-3                    start：0 end：5
compute end ----ForkJoinPool-1-worker-3                    start：0 end：10

执行流程

执行说明

ForkJoinPool与ThreadPool的不同是：ForkJoinPool中的任务是有同步关系的，某个任务必须在其它的某个/某些任务完成后才能进行，甚至需要使用其它任务的计算结果。典型的例子是并发的快速排序以及并发的查找最大值。

提交给ForkJoinPool的任务是ForkJoinTask。提交的时候，ForkJoinTask和ForkJoinPool之间记录双向指针。ForkJoinTask中可以创建新的ForkJoinTask，并通过fork()提交给所在的ForkJoinPool。所有的ForkJoinTask都可以在提交后使用join()方法获取计算结果。join()方法是线程阻塞的。

ForkJoinPool的实现极为复杂，其设计目标是尽量使得所有线程都在工作，并且减少线程之间的竞争。由于核心线程数大于等于CPU核数，这就意味着CPU资源被充分利用。大致的实现方法是：

• 一个数组(workQueues)，长度大于等于CPU核数，最大为64，数组成员是任务队列。偶数位置放外部提交的任务，奇数位置放fork()出来的子任务。偶数位置的任务队列不配线程，它们是shared的；奇数位置的任务队列配一个专属的worker线程。

• 任务队列是一个Deque。线程取自己队列里的任务来执行时，用的是栈的方式，后进先出；线程执行别人的队列里的任务时(叫work stealing)，用的是队的方式，先进先出。

• 每个worker线程每一轮的工作是：

• 从workQueues的一个随机位置开始往后找，找到第一个可以从队列中取出来的任务(通常是偷别人一个)，执行这个取出来的任务。(外部提交的任务和fork()出来的子任务用奇偶位置间隔就是为了随机找任务的时候不会落入一大片同类任务的区域。)

• 执行完这第一个(通常是偷来的)任务之后，回到自己队列，不断pop()任务出来执行，直到队列为空。

• 一个外部任务提交到哪个位置取决于调用提交任务的线程。每个线程维护一个数，只要这个数不变，每次提交任务都到同一个任务队列；如果那个队列太忙了，就会提交失败，这时候就把数变一下，重新提交，直到成功，将来的任务也都会提交到这个新地方。

• 已有任务fork()出来的子任务放到哪里，取决于它被哪个worker线程执行：它总被放到执行这个任务的线程所拥有的任务队列中。这意味着：

• 外部提交的任务(偶数位置上的)，总是会用偷的方式执行的。它fork()出来的任务放在哪里取决于是被哪个线程偷的。

• 子任务(奇数位置上的)，如果被自己的线程执行了，fork()出来的子任务还在自己的任务队列里。如果被别的线程偷去执行了，fork()出来的任务就到哪个偷窃线程的队列里去了。

• 新的任务队列及其对应的worker线程的产生是被动的方式：每当有新任务来的时候，都会调用signalWork()方法。这个方法检查当前的线程是否够用，如果不够用，就释放一个闲置线程(idle worker)；如果没有闲置线程，就创建一个新线程。

• 新线程创建后，配给它一个新建的任务队列，然后在workQueues里找一个合适的位置(奇数位置)把任务队列放进去。这个位置不是随机的，而是算出来的：从上一次新建队列的位置向后移动一个固定的偏移量。

• join()的执行(注意它是阻塞的)：如果调用时该任务已经完成，则返回结果；如果没有，则试图在当前线程立即完成它；如果做不到，必须等待，就尽量让当前线程在等待期间干点别的，充分利用它所在CPU核的计算资源。具体方法是：

• 如果发起调用的ForkJoinTask和目标任务不在同一个队列，则试图把目标任务从队列中unpush()出来(只有在队的最上面才能被unpush())执行。如果不成功，就block，等待目标任务完成。

• 如果发起调用的ForkJoinTask和目标任务在同一个队列，试着把目标任务从队列里remove出来执行。如果不成功或者队列为空，说明目标被偷了，这时就去帮偷取者执行一个任务。如果执行完回来目标任务还没有完成，就block，block之前让线程池释放一个空闲线程或者创建一个线程，作为补偿。这个补偿线程由于自己的任务队列为空，它的工作就是偷别人的任务来干，也就是说它“补偿”了自己block期间损失的算力。

ForkJoinPool的static{}块中构造了一个对象，可以用ForkJoinPool.commonPool()取得。通常用这个ForkJoinPool就可以了，不用自己new()一个出来用，也不太需要再继承ForkJoinPool做更复杂的实现了。

ForkJoinPool的主要功能是并行实现分治算法。分治算法的本质是把任务不断切小，再把结果逐层归纳。这就意味着并行可以使得每一层的计算同时执行，但是层的深度是不能改变的，也就是说，算法的时间复杂度取决于层数。以归并排序为例，在单核上，复杂度是O(NlogN)，其中N是每一轮的计算量，logN是轮数。并行计算是每一轮都可以以O(1)的速度完成，只要并发度大于N。但是轮数logN是不可能被缩减的，因为轮次之间有依赖关系，上一轮的结果归纳需要下一轮的计算结果作为输入，也就是说轮次之间必须是线性完成的。这在ForkJoinPool中表现为：任务开始后，某个线程把fork()后的两个子任务以入栈的方式压入自己的队列，之后再取出栈顶计算，又会fork()出两个子任务压栈，一直下去。这个过程中一旦有别的线程来偷任务，就会有某个子任务以及它的子任务们被转移到另一个任务队列中完成。如果有p个线程，p大于等于CPU核数，由于互相偷，最终就会有p个任务队列在并发执行。但是join()的时候，发起join()的线程无论是自己努力去完成必须完成的子任务还是block住等其它的线程完成所有的子任务，所需要的时间都是一样长的，就是logL次子任务计算，L是它往下的层数。

从这个例子可以看出，ForkJoinPool的设计思想是每个线程维护自己的任务队列，以减少资源竞争，大家可以独立完成自己的任务；再通过偷的方式将热点地区的计算任务散布到其它线程，实现负载均衡。最终这个算法实现了：忙的时候大家各干各的，互不干扰(因为每一轮每个worker要把自己的任务队列执行完，才能进入下一轮偷别人一个)，并且总是把已经开始执行的外部任务执行完成后再去接新的外部任务来做(外部任务没有配线程，因此忙的时候所有的CPU都在执行被fork()出来的子任务)；闲的时候一有活儿大家都扑上去抢着干，新提交的外部任务能够能迅速占据所有CPU。