原理

Fork-Join 是一种并行计算模式，它通常用于解决递归式或者分治式的问题。其原理基于将一个大的任务划分成若干个小任务，然后并行地执行这些小任务，最后将它们的结果合并起来得到最终的结果。
具体来说，Fork-Join 模式包含两个关键步骤：分解（Fork）和合并（Join）。

1. 分解（Fork）
   在这一步骤中，大任务被分解成若干个小任务，通常采用递归或者分治的方式来实现。每个小任务相对独立，可以被并行执行。
2. 合并（Join）
   在这一步骤中，各个小任务并行执行完毕后，它们的结果被合并起来得到最终的结果。通常采用递归的方式，从底层的任务开始，不断地将结果向上合并，直到得到最终的结果。

Fork-Join 模式通常使用线程池来管理任务的执行。Java 中的 ForkJoinPool 类提供了对 Fork-Join 模式的支持，它使用了工作窃取（Work-Stealing）算法来提高并行计算的效率。在工作窃取算法中，每个线程都维护一个任务队列，当一个线程完成自己的任务后，它会从其他线程的任务队列中偷取任务来执行，这样可以避免线程因为任务执行完毕而空闲的情况，从而提高了整体的并行效率。

总的来说，Fork-Join 模式通过将大任务分解成小任务，并行执行这些小任务，然后合并结果，以达到提高计算效率的目的。

在网上找的图：

使用例子

package conturrent.model.forkjoin;

import org.junit.Test;
import java.util.Arrays;
import java.util.concurrent.*;

public class CountTest {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ForkJoinPool forkJoinPool = new ForkJoinPool(3);
        //创建一个计算任务，计算 由1加到12
        CountTask countTask = new CountTask(1, 12);
        Future<Integer> future = forkJoinPool.submit(countTask);
        System.out.println("最终的计算结果：" + future.get());
    }
    
    @Test
    public void testMain () throws ExecutionException, InterruptedException {
        int[] ints = new int[1000];
        for (int i = 0; i < 1000; i++) {
            ints[i] = i;
        }

        // Arrays的parallelSort使用的就是forkjoin
        Arrays.parallelSort(ints);
        // ForkJoinTask<Integer> submit = ForkJoinPool.commonPool().submit();
    }
}

class CountTask extends RecursiveTask<Integer> {

    private static final int THRESHOLD = 2; // 阀值
    private int start; // 起始位置
    private int end; // 结束位置

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

    @Override
    protected Integer compute() {
        int sum = 0;
        boolean canCompute = (end - start) <= THRESHOLD;

        //任务已经足够小，可以直接计算，并返回结果
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            System.out.println("执行计算任务，计算    " + start + "到 " + end + "的和  ，结果是：" + sum + "   执行此任务的线程：" + Thread.currentThread().getName());
            return sum;
        } else { //任务过大，需要切割
            System.out.println("任务过大，切割的任务：  " + start + "加到 " + end + "的和       执行此任务的线程：" + Thread.currentThread().getName());
            int middle = (start + end) / 2;

            //切割成两个子任务
            CountTask leftTask = new CountTask(start, middle);
            CountTask rightTask = new CountTask(middle + 1, end);

            //执行子任务
            leftTask.fork();
            rightTask.fork();
            
            //等待子任务的完成，并获取执行结果
            invokeAll(leftTask,rightTask);
            return leftTask.join() + rightTask.join();
        }

    }
}