深入解析Java中的ForkJoinPool：分而治之，并行处理的利器

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
 
public class ForkJoinPoolExample extends RecursiveTask<Integer> {
 
    // 当数组小于此大小时，使用普通方法计算求和
    private static final int THRESHOLD = 1000;
    private int[] data;
    private int start;
    private int end;
 
    public ForkJoinPoolExample(int[] data, int start, int end) {
        this.data = data;
        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 += data[i];
            }
        } else {
            // 如果任务大于阈值，则分割任务
            int middle = (start + end) / 2;
            ForkJoinPoolExample leftTask = new ForkJoinPoolExample(data, start, middle);
            ForkJoinPoolExample rightTask = new ForkJoinPoolExample(data, middle, end);
 
            // 执行子任务
            leftTask.fork();
            rightTask.fork();
 
            // 等待子任务执行完毕并得到结果
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();
 
            // 合并子任务的结果
            sum = leftResult + rightResult;
        }
 
        return sum;
    }
 
    public static void main(String[] args) {
        int[] data = new int[1_000_000];
        for (int i = 0; i < data.length; i++) {
            data[i] = i;
        }
 
        ForkJoinPool pool = new ForkJoinPool();
 
        // 提交任务，任务将在池中并行处理
        ForkJoinPoolExample task = new ForkJoinPoolExample(data, 0, data.length);
        long startTime = System.currentTimeMillis();
        int result = pool.invoke(task);
        long endTime = System.currentTimeMillis();
 
        System.out.println("Result: " + result);
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

这段代码展示了如何使用ForkJoinPool来并行处理一个大的数组求和任务。compute方法中，当任务大于一个阈值时，它会递归地分割成两个子任务并分别执行它们。然后它会等待子任务完成并将它们的结果合并起来。主方法中，我们创建了一个ForkJoinPool，并提交了一个ForkJoinPoolExample任务。这个任务会在多个核心上并行执行，从而显著减少处理大规模数据集的时间。