forkjoin

ForkJoin框架是Java并发包(java.util.concurrent)的一部分，主要用于并行计算，特别适合处理可以递归划分成许多子任务的问题，例如大数据处理、并行排序等。该框架的核心思想是将一个大任务拆分成多个小任务（Fork），然后将这些小任务的结果汇总起来（Join），从而达到并行处理的效果。

public class TheKingRecursiveSumTask extends RecursiveTask<Long> {
    private static final AtomicInteger taskCount = new AtomicInteger();
    private final int sumBegin;
    private final int sumEnd;
    private final int threshold;

    public TheKingRecursiveSumTask(int sumBegin, int sumEnd, int threshold) {
        this.sumBegin = sumBegin;
        this.sumEnd = sumEnd;
        this.threshold = threshold;
    }

    @Override
    protected Long compute() {
        if (sumEnd - sumBegin > threshold) {
            TheKingRecursiveSumTask sumTask1 = new TheKingRecursiveSumTask(sumBegin, (sumBegin + sumEnd) / 2, threshold);
            TheKingRecursiveSumTask sumTask2 = new TheKingRecursiveSumTask((sumBegin + sumEnd) / 2, sumEnd, threshold);
            sumTask1.fork();
            sumTask2.fork();
            taskCount.incrementAndGet();
            return sumTask1.join() + sumTask2.join();
        }
        long result = 0L;
        for (int i = sumBegin; i < sumEnd; i++) {
            result += i;
        }
        return result;
    }

    public static AtomicInteger getTaskCount() {
        return taskCount;
    }


    private static void computeByForkJoin(int sumBegin, int sumEnd) {
        ForkJoinPool forkJoinPool = new ForkJoinPool(16);
        long forkJoinStartTime = System.nanoTime();
        TheKingRecursiveSumTask theKingRecursiveSumTask = new TheKingRecursiveSumTask(sumBegin, sumEnd, 100);
        Long forkJoinResult = forkJoinPool.invoke(theKingRecursiveSumTask);
        System.out.println("=============");
        System.out.println("ForkJoin任务拆分：" + TheKingRecursiveSumTask.getTaskCount());
        System.out.println("ForkJoin计算结果：" + forkJoinResult);
        System.out.println("ForkJoin计算耗时：" + (System.nanoTime() - forkJoinStartTime));
    }

    private static void computeBySingleThread(int sumBegin, int sumEnd) {
        long computeResult = 0L;
        long startTime = System.nanoTime();
        for (int i = sumBegin; i < sumEnd; i++) {
            computeResult += i;
        }
        System.out.println("===========");
        System.out.println("单线程计算结果：" + computeResult);
        System.out.println("单线程计算耗时：" +(System.nanoTime() - startTime));
    }

    public static void main(String[] args) {
        int sumBegin = 0, sumEnd = 100000000;
        computeByForkJoin(sumBegin, sumEnd);
        computeBySingleThread(sumBegin, sumEnd);
    }
}