---

前言

使用Fork/Join框架首先要考虑到的是如何分割任务,分割之后,根据join 再进行任务结果的合并,也就是类似二分法的,分而治之的理念;

---

一、fork/join是什么？

• fork 拆分任务,将大任务拆分成小任务,拆的有多小呢? 这个可以根据自己的情况而定
• join 合并拆分的结果, 无论如何拆分,最终的计算结果应该是对的

二、使用步骤

废话不多说,直接上代码

public class ForkJoin使用 extends RecursiveTask<Integer> {

    private static int yuzhi = 10;
    private Integer start;
    private Integer end;


    public ForkJoin使用(Integer start, Integer end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        Integer res = 0;

        if ((end - start) <= 10) {
            for (Integer i = start; i <= end; i++) {
                res += i;
            }
        } else {

            Integer middle = (start + end) / 2;
            ForkJoin使用 forkJoin使用 = new ForkJoin使用(start, middle);
            ForkJoin使用 forkJoin使用1 = new ForkJoin使用(middle + 1, end);

            ForkJoinTask<Integer> fork = forkJoin使用.fork();
            ForkJoinTask<Integer> fork1 = forkJoin使用1.fork();
            try {
                res = fork.get() + fork1.get();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            } catch (ExecutionException e) {
                throw new RuntimeException(e);
            }
        }

        return res;
    }


    @SneakyThrows
    public static void main(String[] args) {

        ForkJoinPool forkJoinPool = new ForkJoinPool();

        ForkJoin使用 forkJoin = new ForkJoin使用(1, 100);

        ForkJoinTask<Integer> submit = forkJoinPool.submit(forkJoin);

        Integer integer = submit.get();

        System.out.println(integer);

    }
}

• 我的最大任务是计算 1 -100 的和
• fork拆分: 我想每个最小子任务执行10的数的相加,这就是具体拆分的情况
• join 我利用join 得到每个子任务的执行的结果
• 整体是一个递归执行
• (end - start) <= 10 每次递归通过此判断是否应该继续拆分子任务
• 不满足上述条件,继续拆分,满足直接计算
• ForkJoinPool 通过这个框架执行我们的最大任务
• RecursiveTask 继承它,然后重写compute 这就是这个递归的核心逻辑了

---

总结

fork join 框架的思想就是通过分而治之的理念,去处理大量数据; 核心是利用递归处理,底层也是通过多线程实现;