JUC——ForkJoin（分而治之）

引入

ForkJoin框架是处理任务的一种决策——“大事化小，小事化了”是其主要思想。

分而治之

利用此框架的思想，将比较大的任务拆分成小任务，再借助多线程分别处理计算，最后在把结果合并起来，返回最终的结果。

上图：

可见画功了得！！

• 啊呸！！！

实现

通过实现一个小例子来理解这个过程。

• 实现从 1 加到 10亿。

创建任务类：

import java.util.concurrent.RecursiveTask;

/**
 * “这看起来很像递归，有关类的递归”
 * “淦！就是！”
 * 继承 RecursiveTask类，，翻译过来就是 “递归任务”
 */
public class ForkJoin_Demo extends RecursiveTask<Long> {

    private Long start = 0L;
    private Long end = 0L;

    public ForkJoin_Demo(Long start,Long end){
        this.start = start;
        this.end = end;
    }

    //临界值
    Long temp = 10000L;

    @Override
    protected Long compute() {
        if((end - start) < temp){
            long sum = 0L;
            for (long i = start; i <= end ; i++) {
                sum += i;
            }
            return sum;
        }else { //超过临界值之后，便开始“分而治之”
            long middle = (end+start+1)/2;//中间值

            ForkJoin_Demo task1 = new ForkJoin_Demo(start,middle);
            task1.fork();//拆分任务，把任务压入线程队列
            ForkJoin_Demo task2 = new ForkJoin_Demo(middle+1,end);
            task2.fork();//拆分任务，把任务压入线程队列

            //合并
            return task1.join() + task2.join();
        }
    }
}

任务类必须继承 RecursiveTask 或 RecursiveAction，，

因为他俩是 ForkJoinTask 的子类。

二者区别：

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

这其中的多线程并行过程也采取了 工作密取 的思想：

分而治之 分割了每个任务之后，某个线程提前完成了任务，就会去其他线程偷取任务来完成，加快执行效率。同时，第一个分配的线程是从队列中的头部拿任务，当完成任务的线程去其他队列拿任务的时候是从尾部拿任务，所以这样就避免了竞争。

显然，任务队列为一个双端队列。

接下来是执行：

private static void test1() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoin_Demo(0L,10_0000_0000L);
        ForkJoinTask<Long> submit = pool.submit(task);
        Long sum = submit.get();

        System.out.println(sum);

        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - start));
    }

ForkJoinTask 任务的执行 需要借助—— ForkJoinPool

看他的实现类，是不是似曾相识。

没错，也是线程池那一套

其实 ForkJoinPool 就是一个 “CPU密集型的自定义线程池” ！

因为要尽可能的并行，所以线程个数最好是 CPU 的核数—— 一个核可以支持一个线程。

所以，此策略不实用单核设备。

单核的话根本不存在并行，还会产生额外的池化和队列化的开销。

最后我们对比测试一下：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //普通方法 （循环）
        test();
        //进阶方法 （ForkJoin递归任务）
        test1();
        //最快方法 （Stream流计算）
        test2();

    }

    //普通方法
    public static void test(){
        long start = System.currentTimeMillis();

        long sum = 0L;
        for (int i = 1; i <= 10_0000_0000; i++) {
            sum += i;
        }
        System.out.println(sum);

        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - start));
    }

    //进阶方法
    // 适合CPU密集型 线程池里的线程个数 为 计算机CPU核数
    // System.out.println("获取当前计算机CPU核数"+Runtime.getRuntime().availableProcessors());
    private static void test1() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoin_Demo(0L,10_0000_0000L);
        ForkJoinTask<Long> submit = pool.submit(task);
        Long sum = submit.get();

        System.out.println(sum);

        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - start));
    }

    //最佳方法
    public static void test2(){
        //利用 Stream 流计算 来提高效率
        long start = System.currentTimeMillis();

        long sum = LongStream.rangeClosed(0, 10_0000_0000).parallel().reduce(0, Long::sum);
        System.out.println(sum);

        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - start));
    }
}

执行结果：

500000000500000000
时间：297
500000000500000000
时间：197
500000000500000000
时间：171

显然，在多核设备下，ForkJoin 方法 要比普通单线程方法要快，但相比于 Stream流计算来说，还是不行。

可见这个1.8新特性还是很厉害的。
我这里有一篇做参考：Java——Stream流计算（java.util.stream）