一、ForkJoin 框架核心认知

ForkJoin 是 Java 7 引入的并行计算框架，基于 “分而治之”（Divide and Conquer）思想，专门解决大任务拆小、小任务并行执行、结果合并的场景，底层依赖 ForkJoinPool 线程池，核心优势是利用工作窃取（Work Stealing） 算法提升线程利用率。

核心概念拆解

1. Fork（拆分）：把一个大任务拆分成多个独立的子任务，子任务可并行执行。
2. Join（合并）：等待所有子任务执行完成，合并子任务的结果，得到最终结果。
3. 工作窃取：空闲线程会主动 “窃取” 其他线程队列里的任务执行，避免线程闲置，提升整体效率。
4. 核心组件：
   • ForkJoinPool：专属线程池，管理执行 ForkJoin 任务的线程。
   • ForkJoinTask：抽象任务类，常用子类：
     • RecursiveTask：有返回值的任务（最常用）。
     • RecursiveAction：无返回值的任务。
     • CountedCompleter：完成任务后触发回调的任务。

二、核心工作原理

1. 任务拆分：大任务通过fork()方法拆分成多个小任务，直到达到 “最小任务粒度”（如计算 1000 以内的数就不再拆分）。
2. 工作窃取机制：
   • 每个线程都有自己的双端任务队列（Deque），自己的任务优先从队列头部取。
   • 当线程空闲时，会从其他线程的队列尾部窃取任务执行（避免竞争）。
   • 适合 “计算密集型、任务拆分均匀” 的场景，能最大化利用 CPU 多核资源。
3. 结果合并：子任务执行完成后，通过join()方法获取结果，逐层合并得到最终结果。

三、实战案例（计算 1~N 的和）

以经典的 “累加计算” 为例，演示 ForkJoin 的使用，对比普通循环，体现并行优势。

完整代码

java

运行

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

/**
 * ForkJoin计算1~N的累加和
 * 核心：拆分任务到最小粒度（如阈值1000），并行计算后合并结果
 */
public class ForkJoinSumExample extends RecursiveTask<Long> {
    // 最小任务粒度：小于1000时直接计算，不再拆分
    private static final long THRESHOLD = 1000L;
    private final long start;
    private final long end;

    // 构造方法：初始化任务的计算范围
    public ForkJoinSumExample(long start, long end) {
        this.start = start;
        this.end = end;
    }

    // 核心方法：实现任务拆分与计算逻辑
    @Override
    protected Long compute() {
        // 计算当前任务的范围长度
        long length = end - start + 1;
        
        // 1. 如果任务足够小，直接计算（递归终止条件）
        if (length <= THRESHOLD) {
            long sum = 0;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }
        
        // 2. 任务太大，拆分成两个子任务
        long mid = start + (end - start) / 2;
        ForkJoinSumExample leftTask = new ForkJoinSumExample(start, mid); // 左半部分
        ForkJoinSumExample rightTask = new ForkJoinSumExample(mid + 1, end); // 右半部分
        
        // 拆分执行左任务（异步）
        leftTask.fork();
        // 执行右任务（当前线程直接执行，减少线程创建开销）
        Long rightResult = rightTask.compute();
        // 获取左任务结果（阻塞等待）
        Long leftResult = leftTask.join();
        
        // 3. 合并子任务结果
        return leftResult + rightResult;
    }

    // 测试方法
    public static void main(String[] args) {
        // 要计算的范围：1~100000000
        long n = 100000000L;
        
        // 1. 使用ForkJoin计算
        ForkJoinPool forkJoinPool = new ForkJoinPool(); // 默认核心数=CPU核心数
        ForkJoinSumExample task = new ForkJoinSumExample(1, n);
        long startTime = System.currentTimeMillis();
        Long forkJoinSum = forkJoinPool.invoke(task); // 提交任务并获取结果
        long forkJoinTime = System.currentTimeMillis() - startTime;
        
        // 2. 普通循环计算（对比）
        startTime = System.currentTimeMillis();
        long normalSum = 0;
        for (long i = 1; i <= n; i++) {
            normalSum += i;
        }
        long normalTime = System.currentTimeMillis() - startTime;
        
        // 输出结果
        System.out.println("ForkJoin计算结果：" + forkJoinSum + "，耗时：" + forkJoinTime + "ms");
        System.out.println("普通循环计算结果：" + normalSum + "，耗时：" + normalTime + "ms");
        
        // 关闭线程池
        forkJoinPool.shutdown();
    }
}

代码关键解释

1. 阈值（THRESHOLD）：设置 1000 是经验值，太小会导致拆分过度（线程调度开销大），太大则无法充分利用并行优势，需根据业务调整。
2. fork() vs compute()：
   • fork()：把任务提交到线程池，异步执行，当前线程不阻塞。
   • compute()：当前线程直接执行任务，减少线程切换开销（本例中右任务直接执行，左任务 fork）。
3. join()：阻塞等待子任务执行完成，获取结果。

执行结果（参考）

plaintext

ForkJoin计算结果：5000000050000000，耗时：28ms
普通循环计算结果：5000000050000000，耗时：89ms

（注：耗时因 CPU 核心数、配置不同有差异，计算量越大，ForkJoin 优势越明显）

四、使用场景与注意事项

适用场景

• 计算密集型任务：如大数据量的数值计算、数组排序、文件内容解析汇总。
• 任务可拆分且无状态：拆分后的子任务相互独立，无共享变量（或共享变量需加锁，尽量避免）。
• 大数据量处理：如处理 100 万条数据的统计、过滤，拆分成多个小任务并行执行。

注意事项

1. 避免过度拆分：拆分粒度太小会导致线程调度开销 > 并行收益，需合理设置阈值。
2. 避免 IO 密集型任务：ForkJoin 线程池的线程是 “核心线程”（默认不回收），如果任务包含大量 IO（如读写文件、网络请求），会导致线程阻塞，浪费资源（IO 密集型建议用 ThreadPoolExecutor）。
3. 防止任务死锁：子任务不要等待父任务，避免线程相互阻塞。
4. 资源控制：ForkJoinPool 默认核心数 = CPU 核心数，可通过构造方法指定（如new ForkJoinPool(8)），不要设置过大（超过 CPU 核心数太多会导致线程切换频繁）。

五、ForkJoin vs 普通线程池（ThreadPoolExecutor）

表格

总结

1. 核心逻辑：ForkJoin 框架的核心是 “分（Fork）- 治（并行执行）- 合（Join）”，通过工作窃取算法提升多核 CPU 利用率。
2. 核心用法：继承RecursiveTask（有返回值）/RecursiveAction（无返回值），实现compute()方法，定义拆分逻辑和终止条件，通过ForkJoinPool执行。
3. 使用原则：适合计算密集型、可拆分的无状态任务，合理设置拆分阈值，避免过度拆分和 IO 密集型场景。