Java如何用ForkJoin实现数组并行求和_Java并行计算案例详解-java教程-PHP中文网

Java如何用ForkJoin实现数组并行求和_Java并行计算案例详解

P粉602998670

发布： 2025-11-22 10:49:02

原创

776人浏览过

ForkJoinPool适用于分而治之的并行计算，通过RecursiveTask实现数组求和，利用工作窃取算法提升性能。

java如何用forkjoin实现数组并行求和_java并行计算案例详解

在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));
}

登录后复制

}

MindShow

MindShow官网 | AI生成PPT，快速演示你的想法

1492

查看详情

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上，并行版本通常能显著减少计算时间，尤其是数组较大时。