初识ForkJoin框架

写在前面

最近工作中遇到优化单线程处理一个大任务性能优化的问题，我们首先想到肯定是多线程并行执行，那么又该如何拆分子任务并均匀分配给每个线程执行呢？

也许我们只听过fork/join框架思想并未实战演练，更不了解JDK1.7+为我们提供ForkJoin相关类的API该怎么用。

接下来就让我们一探究竟吧~~

概述

Fork/Join框架核心思想：它可以将一个大的任务拆分成多个子任务进行并行处理，最后将子任务结果合并成最后的计算结果，并进行输出。即为分治算法的核心思想。

Java中为我们提供Fork/Join框架常用相关类有java.util.concurrent.ForkJoinPool、java.util.concurrent.ForkJoinTask等。

ForkJoinTask：我们要使用 ForkJoin 框架，必须首先创建一个 ForkJoin 任务。它提供在任务中执行fork() 和join()操作的机制，通常情况下我们不需要直接继承 ForkJoinTask 类，而只需要继承它的子类，ForkJoin 框架提供了以下两个子类：

• RecursiveAction：用于没有返回结果的任务。
• RecursiveTask：用于有返回结果的任务。

ForkJoinPool：ForkJoinTask 需要通过 ForkJoinPool 来执行，任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。

常用API详解

ForkJoinPool线程池

构造方法

​ 构造方法有三个

• ForkJoinPool()：

  默认 最大并发数为当前机器核数，获取任务模式false（LIFO）

• ForkJoinPool(int parallelism)

  指定最大并发数，获取任务模式false（LIFO）

• ForkJoinPool(int parallelism,ForkJoinWorkerThreadFactory factory,Thread.UncaughtExceptionHandler handler, boolean asyncMode)

  指定最大并发数、创建新线程的工厂、线程异常情况下的处理器、从任务队列获取方式（true为FIFO，false为LIFO）

常用方法

• invoke： 有Join, tasks会被同步到主进程。同步执行
• submit：异步执行，且带Task返回值，可通过task.get 实现同步到主线程
• execute：异步执行tasks，无返回值
• shutdown：关闭线程池，释放资源

任务执行实现类

RecursiveAction适用于创建无返回结果的任务，RecursiveTask 适用于创建有返回结果的任务。

两者都需要实现compute()方法，当把任务放入线程池中，会自动执行compute()方法。

常用方法

• fork：把任务推入当前工作线程的工作队列里
• join：等待任务执行完成
• invoke：同步执行
• InvokeALL：同步执行多个任务，先执行第一个task，其他task调用fork
• get：获取任务执行结果

fork和invokeAll区别

在fork/join模式中，我们在子任务中常常使用fork方法来让子任务采取异步方法执行，但是这不是高效的实现方法，尤其是对于forkjoinPool在线程有限的情况下，子任务直接使用fork方法执行时间比使用invokeAll执行时间要长。

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

执行compute()方法的线程本身也是一个Worker线程，当对两个子任务调用fork()时，这个Worker线程就会把任务分配给另外两个Worker，但是它自己却停下来等待不干活了！这样就白白浪费了Fork/Join线程池中的一个Worker线程，导致了4个子任务至少需要7个线程才能并发执行。

---

案例

功能实现：计算数组所有元素和

任务实现类

class SumTask extends RecursiveTask<Long> {

    static final int THRESHOLD = 100;
    long[] array;
    int start;
    int end;

    SumTask(long[] array, int start, int end) {
    this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if (end - start <= THRESHOLD) {
            // 如果任务足够小,直接计算:
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            System.out.println(String.format("compute %d~%d = %d", start, end, sum));
            return sum;
        }
        // 任务太大,一分为二:
        int middle = (end + start) / 2;
        System.out.println(String.format("split %d~%d ==> %d~%d, %d~%d", start, end, start, middle, middle, end));
        SumTask subtask1 = new SumTask(this.array, start, middle);
        SumTask subtask2 = new SumTask(this.array, middle, end);
        invokeAll(subtask1, subtask2);
        Long subresult1 = subtask1.join();
        Long subresult2 = subtask2.join();
        Long result = subresult1 + subresult2;
        System.out.println("result = " + subresult1 + " + " + subresult2 + " ==> " + result);
        return result;
    }
}

main方法

public static void main(String[] args) throws Exception {
    // 创建随机数组成的数组:
    long[] array = new long[400];
    fillRandom(array);
    // fork/join task:
     try {
        fjp = new ForkJoinPool(4); // 最大并发数4
        ForkJoinTask<Void> task = new SumTask(array, 0, array.length);
    	long startTime = System.currentTimeMillis();
        Long result = fjp.invoke(task);
    	long endTime = System.currentTimeMillis();
        System.out.println("Fork/join sum: " + result + " in " + (endTime - startTime) + " ms.");
    } finally {
        fjp.shutdown();
    }
}
private static void fillRandom(long[] array) {
    Random random = new Random();
    for (int i = 0; i < array.length; i++) {
        array[i] = random.nextInt();
    }
}

执行结果

split 0~400 ==> 0~200, 200~400
split 0~200 ==> 0~100, 100~200
compute 0~100 = -17962419694
compute 100~200 = 15279919598
split 200~400 ==> 200~300, 300~400
compute 200~300 = 12716598902
compute 300~400 = -3798031349

注意事项

• 使用多次ForkJoinPool.submit(task)提交任务时，若需要等待所有任务执行完再处理其他逻辑，需要执行task.join或task.get等待任务执行完成。
• 在compute()中任务拆分后执行任务使用invokeAll执行，避免使用fork，避免空闲线程，充分利用了线程池。
• 使用完线程池注意调用shutdown关闭线程池
• ForkJoinPool 最适合的是计算密集型的任务，如果存在 I/O，线程间同步，sleep() 等会造成线程长时间阻塞的情况时，最好配合使用 ManagedBlocker。目的是把cpu的核跑满，只有计算密集型能跑满cpu，IO密集型可以开更多线程去并发跑。
• 线程池并发线程数公式：计算密集型parallelism = CPU核数+1，IO密集型parallelism = CPU核数x2

写在最后

Fork/Join框架已小试牛刀完成，这只是开始，还有更多的思想和技术等待我们去学习探索。

加油！？