ForkJoinTask 并行计算使用案例

ForkJoinTask 是 Java 并行计算框架 ForkJoinPool 里的一个核心组件，适用于将大任务拆分成多个小任务并行执行，然后合并结果。真实的应用场景包括 大数据处理、递归计算、并行搜索、批量任务执行 等。

下面是一个真实代码案例，演示如何使用 RecursiveTask（ForkJoinTask 的子类）并行计算大数组的总和：

---

案例：使用 ForkJoinTask 并行计算大数组的总和

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

class SumTask extends RecursiveTask<Long> {
    private static final int THRESHOLD = 1000; // 任务拆分的阈值
    private final int[] array;
    private final int start, end;

    public SumTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        int length = end - start;
        if (length <= THRESHOLD) {
            // 任务足够小，直接计算
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            // 任务太大，拆分
            int mid = start + length / 2;
            SumTask leftTask = new SumTask(array, start, mid);
            SumTask rightTask = new SumTask(array, mid, end);

            // 并行执行两个子任务
            leftTask.fork();
            long rightResult = rightTask.compute();
            long leftResult = leftTask.join();

            // 合并结果
            return leftResult + rightResult;
        }
    }
}

public class ForkJoinExample {
    public static void main(String[] args) {
        // 生成一个大数组
        int size = 10_000_000;
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = i + 1; // 1, 2, 3, ..., size
        }

        // 创建 ForkJoin 线程池
        ForkJoinPool pool = new ForkJoinPool();

        // 创建任务
        SumTask task = new SumTask(array, 0, array.length);

        // 执行任务并获取结果
        long result = pool.invoke(task);

        System.out.println("Array sum: " + result); // 预计输出 50000005000000
    }
}

---

代码解析

1. 拆分任务
   • 如果任务长度小于等于 THRESHOLD（1000），直接计算。
   • 否则，拆分为左右两个子任务，递归执行。
2. 并行执行
   • leftTask.fork()：异步执行左侧子任务。
   • rightTask.compute()：直接计算右侧任务，避免不必要的线程切换（优化）。
   • leftTask.join()：等待左侧任务完成并获取结果。
3. 结果合并
   • leftResult + rightResult 得到最终的数组总和。

应用场景

• 大数组计算（如示例中求和）
• 并行递归算法（如快速排序、斐波那契数列）
• 日志或文件批量处理
• 大规模数据聚合（如 MapReduce）