当前位置：首页 > 文章列表 > 文章 > java教程 > JavaForkJoinTask并行任务拆分教程

JavaForkJoinTask并行任务拆分教程

2026-01-27 14:16:35 0浏览收藏

在文章实战开发的过程中，我们经常会遇到一些这样那样的问题，然后要卡好半天，等问题解决了才发现原来一些细节知识点还是没有掌握好。今天golang学习网就整理分享《Java如何用ForkJoinTask实现并行任务拆分》，聊聊，希望可以帮助到正在努力赚钱的你。

ForkJoinTask是ForkJoinPool框架核心，用于分治并行处理计算密集型任务。它有RecursiveTask（有返回值）和RecursiveAction（无返回值）两个子类，通过fork拆分任务、compute执行、join合并结果，结合工作窃取算法提升并发效率，适用于数组求和、排序等场景，需合理设置阈值避免过度拆分，推荐用于CPU密集型任务以发挥多核性能优势。

在Java中如何使用ForkJoinTask拆分并行任务_ForkJoinTask并行实践

在Java中，ForkJoinTask 是 ForkJoinPool 框架的核心组成部分，适用于将一个大任务拆分成多个小任务并行执行，最后合并结果。这种“分而治之”的策略特别适合处理可递归分解的计算密集型任务，比如数组求和、归并排序、树遍历等。

理解 ForkJoinTask 与 ForkJoinPool

ForkJoinTask 是一个抽象类，表示可以被 ForkJoinPool 执行的任务。它有两个常用子类：

RecursiveAction：用于没有返回值的任务（如打印、排序）。
RecursiveTask：用于有返回值的任务（如求和、查找最大值）。

ForkJoinPool 是一个特殊的线程池，专为运行大量小型 ForkJoinTask 而设计，使用工作窃取算法（work-stealing）提高并发效率。

使用 RecursiveTask 实现并行求和

下面以对一个大数组进行并行求和为例，展示如何使用 RecursiveTask 进行任务拆分和结果合并。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class SumTask extends RecursiveTask {
private static final int THRESHOLD = 1000; // 单个任务处理的最大元素数
private long[] array;
private int start, end;
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 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 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); // 应输出 50005000
}
}

在这个例子中，当数组范围小于阈值时直接计算；否则拆成两个子任务，一个通过 fork() 提交异步执行，另一个立即 compute()，最后用 join() 获取异步结果。

使用 RecursiveAction 处理无返回值任务

如果任务不需要返回结果，比如对数组每个元素加一个固定值，可以继承 RecursiveAction。

import java.util.concurrent.RecursiveAction;
public class IncrementTask extends RecursiveAction {
private static final int THRESHOLD = 1000;
private long[] array;
private int start, end;
public IncrementTask(long[] 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++) {
            array[i]++;
        }
    } else {
        int mid = (start + end) / 2;
        IncrementTask left = new IncrementTask(array, start, mid);
        IncrementTask right = new IncrementTask(array, mid, end);

        left.fork();
        right.compute();
        left.join();
    }
}
}

调用方式与 RecursiveTask 类似，使用 invoke() 或 execute() 提交任务即可。