在Java中如何使用ForkJoinPool分支合并任务-java教程-PHP中文网

在Java中如何使用ForkJoinPool分支合并任务

P粉602998670

发布： 2025-10-03 09:45:02

原创

509人浏览过

ForkJoinPool基于工作窃取算法，通过RecursiveTask和RecursiveAction实现分治计算，适用于拆分任务的计算密集型场景，合理设置阈值可提升并行性能。

在java中如何使用forkjoinpool分支合并任务

在Java中，ForkJoinPool 是用于高效执行分治算法的线程池，特别适合可以拆分成多个小任务的计算密集型操作。它基于“工作窃取”（work-stealing）算法，空闲线程可以从其他线程的任务队列中“窃取”任务执行，提高CPU利用率。

1. ForkJoinPool 的基本原理

ForkJoinPool 配合 ForkJoinTask 使用，常见的子类有 RecursiveAction（无返回值）和 RecursiveTask（有返回值）。核心思想是：

分解（Fork）：将大任务拆成多个子任务，并提交到池中异步执行。
合并（Join）：等待子任务完成，并合并它们的结果。

2. 使用 RecursiveTask 实现有返回值的任务

假设我们要计算一个数组的和，可以通过分治方式实现：

立即学习“Java免费学习笔记（深入）”；

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
<p>public class SumTask extends RecursiveTask<Long> {
private static final int THRESHOLD = 1000; // 拆分阈值
private long[] array;
private int start, end;</p><pre class='brush:java;toolbar:false;'>public SumTask(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;
    } else {
        // 拆分为两个子任务
        int mid = (start + end) / 2;
        SumTask left = new SumTask(array, start, mid);
        SumTask right = new SumTask(array, mid, end);

        left.fork(); // 异步执行左任务
        right.fork(); // 异步执行右任务

        return left.join() + right.join(); // 合并结果
    }
}

public static void main(String[] args) {
    long[] data = new long[10000];
    for (int i = 0; i < data.length; i++) {
        data[i] = i + 1;
    }

    ForkJoinPool pool = new ForkJoinPool();
    SumTask task = new SumTask(data, 0, data.length);
    long result = pool.invoke(task); // 执行任务
    System.out.println("总和：" + result);
    pool.shutdown();
}

登录后复制

}

3. 使用 RecursiveAction 处理无返回值任务

如果任务不需要返回结果，比如打印数组元素，可以用 RecursiveAction：

如知AI笔记

如知笔记——支持markdown的在线笔记，支持ai智能写作、AI搜索，支持DeepseekR1满血大模型

查看详情

立即学习“Java免费学习笔记（深入）”；

import java.util.concurrent.RecursiveAction;
<p>public class PrintTask extends RecursiveAction {
private static final int THRESHOLD = 50;
private int[] array;
private int start, end;</p><pre class='brush:java;toolbar:false;'>public PrintTask(int[] array, int start, int end) {
    this.array = array;
    this.start = start;
    this.end = end;
}

@Override
protected void compute() {
    if (end - start <= THRESHOLD) {
        for (int i = start; i < end; i++) {
            System.out.print(array[i] + " ");
        }
    } else {
        int mid = (start + end) / 2;
        PrintTask left = new PrintTask(array, start, mid);
        PrintTask right = new PrintTask(array, mid, end);
        left.fork();
        right.fork();
        left.join();
        right.join();
    }
}

登录后复制

}