任务分发 分而治之 ForkJoinPool

//fork()：开启一个新线程（或是重用线程池内的空闲线程），将任务交给该线程处理。
//join()：等待该任务的处理线程处理完毕，获得返回值。

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.IntStream;
 
public class ForkJoinRecursiveTaskTest {
    /**
     * 可进行处理的数字差，超过了就要进行任务分解
     */
    private  static int threshold = 100;
    public static void main(String[] args) {
        final ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Integer> future = forkJoinPool.submit(new MyRecursiveTask(0, 1000));
        try {
            Integer result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
    private static class MyRecursiveTask extends RecursiveTask<Integer> {
        /**
         * 起始数字
         */
        private final int start;
        /**
         * 终止数字
         */
        private final int end;
        MyRecursiveTask(int start, int end) {
            this.start = start;
            this.end = end;
        }
        @Override
        protected Integer compute() {
            if (end - start <= threshold) {
                // 此范围的数字进行累加,并返回结果
                return IntStream.rangeClosed(start, end).sum();
            } else {
                // 将数据规模进行分解
                int middle = (start + end) / 2;
                // 将分解后的数据分发给子线程
                MyRecursiveTask firstTask = new MyRecursiveTask(start, middle);
                MyRecursiveTask secondTask = new MyRecursiveTask(middle + 1, end);
                // 将子任务，放入执行队列等待执行
//                secondTask.fork();
//                firstTask.fork();
                invokeAll(firstTask, secondTask);
                // 等待子线程任务执行完毕并获取聚合执行结果，
                return firstTask.join() + secondTask.join();
            }
        }
    }
}