ForkJoinPool适用于分而治之的并行计算，通过RecursiveTask实现数组求和，利用工作窃取算法提升性能。
在Java中，ForkJoinPool 是实现并行计算的重要工具，特别适合“分而治之”的任务模型。数组并行求和是典型的可拆分任务，非常适合使用 Fork/Join 框架 来提升性能。下面通过一个完整案例，详细说明如何用 ForkJoin 实现数组的并行求和。
1. ForkJoin 框架核心思想
ForkJoin 框架基于工作窃取（work-stealing）算法，将大任务拆分成小任务（fork），并由多个线程并行执行，完成后合并结果（join）。它适用于可以递归分解的计算密集型任务。
关键组件：
- ForkJoinPool：线程池，负责调度 ForkJoinTask。
- ForkJoinTask：任务抽象类，常用子类是 RecursiveTask（有返回值）和 RecursiveAction（无返回值）。
2. 实现并行求和：RecursiveTask 示例
我们继承 RecursiveTask<Long>，定义一个可拆分的求和任务。
立即学习“Java免费学习笔记（深入）”；
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
<p>public class ParallelSum extends RecursiveTask<Long> {
private static final int THRESHOLD = 1000; // 任务拆分阈值
private final long[] array;
private final int start, end;</p><pre class='brush:java;toolbar:false;'>public ParallelSum(long[] array, int start, int end) {
this.array = array;
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
// 如果任务足够小，直接计算
if (end - start <= THRESHOLD) {
long sum = 0;
for (int i = start; i < end; i++) {
sum += array[i];
}
return sum;
}
// 否则拆分为两个子任务
int mid = (start + end) / 2;
ParallelSum leftTask = new ParallelSum(array, start, mid);
ParallelSum rightTask = new ParallelSum(array, mid, end);
// 并行执行子任务
leftTask.fork();
rightTask.fork();
// 合并结果
return leftTask.join() + rightTask.join();
}
// 静态方法，方便调用
public static long parallelSum(long[] array) {
ForkJoinPool forkJoinPool = ForkJoinPool.commonPool();
return forkJoinPool.invoke(new ParallelSum(array, 0, array.length));
}}
3. 使用示例与性能对比
测试并行与串行求和的性能差异：
public class SumTest {
public static void main(String[] args) {
int size = 10_000_000;
long[] array = new long[size];
for (int i = 0; i < size; i++) {
array[i] = i + 1;
}
<pre class='brush:java;toolbar:false;'> // 并行求和
long start = System.nanoTime();
long parallelResult = ParallelSum.parallelSum(array);
long parallelTime = (System.nanoTime() - start) / 1_000_000;
// 串行求和
start = System.nanoTime();
long serialResult = 0;
for (long v : array) {
serialResult += v;
}
long serialTime = (System.nanoTime() - start) / 1_000_000;
System.out.println("并行结果: " + parallelResult + ", 耗时: " + parallelTime + " ms");
System.out.println("串行结果: " + serialResult + ", 耗时: " + serialTime + " ms");
}}
在多核CPU上，并行版本通常能显著减少计算时间，尤其是数组较大时。
4. 关键细节与优化建议
- 合理设置阈值：THRESHOLD 太小会导致任务拆分过度，增加调度开销；太大则无法充分利用并行性。一般根据数据规模和CPU核心数调整。
- 使用 commonPool：ForkJoinPool.commonPool() 是全局共享的，默认并行度为 CPU 核心数减一，适合大多数场景。
- 避免共享状态：任务应无副作用，确保线程安全。
- 适合计算密集型任务：如果任务包含大量IO或阻塞操作，ForkJoin 不是最佳选择。
基本上就这些。ForkJoin 实现并行求和逻辑清晰，性能优势明显，是掌握 Java 并行编程的重要一步。
