说下Fork/Join框架，与传统线程池有何不同

来源：说下Fork/Join框架，与传统线程池有何不同

一、 标准面试回答模版（建议背诵）

面试官： 说下 Fork/Join 框架，它和传统线程池有什么区别？

Fox版标准回答：

“Fork/Join 框架是 Java 7 引入的，专门用于处理CPU密集型任务的并行计算框架。它的核心思想是 ‘分而治之’ (Divide and Conquer)：把一个大任务拆（Fork）成多个小任务并行执行，最后再把结果合并（Join）。

它与传统线程池（ThreadPoolExecutor）最大的区别在于两点：

1. 任务队列的设计不同：

• 传统线程池共享一个阻塞队列（WorkQueue），所有线程去抢这一个队列里的任务，存在竞争。
• Fork/Join 框架中，每个工作线程都有自己独立的双端队列（Deque）。

1. 工作窃取算法（Work-Stealing）—— 这是核心！

• 在 Fork/Join 中，当一个线程把自己队列里的任务干完了，它不会闲着，而是会去窃取（Steal）其他繁忙线程队列队尾的任务来执行。
• 这极大利用了 CPU 资源，减少了线程空闲时间，并且由于窃取的是队尾，正常线程操作队头，大大减少了锁竞争。”

二、 代码层面对比（Talk is cheap）

面试时，手写一个简单的 Fork/Join 累加求和 例子，最能说明“分而治之”的逻辑。

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

// 1. 继承 RecursiveTask (有返回值) 或 RecursiveAction (无返回值)
public class ForkJoinDemo extends RecursiveTask<Long> {

    private long start;
    private long end;
    // 阈值：决定任务什么时候不再拆分
    private static final long THRESHOLD = 10000; 

    public ForkJoinDemo(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long length = end - start;

        // A. 如果任务足够小，直接计算（Base Case）
        if (length <= THRESHOLD) {
            long sum = 0;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } 
            // B. 如果任务太大，进行拆分（Recursive Case）
        else {
            long middle = (start + end) / 2;

            // 拆分成两个子任务
            ForkJoinDemo leftTask = new ForkJoinDemo(start, middle);
            ForkJoinDemo rightTask = new ForkJoinDemo(middle + 1, end);

            // 核心代码：
            leftTask.fork(); // 1. 异步执行左边任务（推入当前线程队列）
            Long rightResult = rightTask.compute(); // 2. 同步执行右边任务（直接干活）
            Long leftResult = leftTask.join(); // 3. 阻塞等待左边任务结果（利用窃取机制）

            // 或者直接用 invokeAll(leftTask, rightTask); 

            return leftResult + rightResult; // 合并结果
        }
    }

    public static void main(String[] args) {
        // 创建 ForkJoinPool
        ForkJoinPool pool = new ForkJoinPool();
        // 提交任务
        ForkJoinDemo task = new ForkJoinDemo(0, 100000000L);
        long result = pool.invoke(task);
        System.out.println("结果：" + result);
    }
}

三、 深度解析（工作窃取图解）

如果面试官问：“为什么 Fork/Join 比传统线程池快？” 你要甩出这两个概念图。

1. 传统线程池的痛点

所有的 Worker 线程都在抢同一个 Queue 的头。

• 瓶颈：高并发下，队列的锁竞争（Lock Contention）严重。
• 不均：有的线程任务极其耗时，有的线程空闲，但空闲线程帮不上忙。

2. Fork/Join 的“工作窃取” (Work Stealing)

• 双端队列 (Deque)：每个线程把拆分出来的子任务 push 到自己队列的头部。

• 自己干：自己从头部pop 任务出来干（LIFO，后进先出），利用 CPU 缓存亲和性。

• 偷任务：如果线程 A 没事干了，它去线程 B 的队列尾部take 一个任务（FIFO）。

• 优势：

• 无锁/少锁：自己取头，别人偷尾，互不干扰，锁竞争极小。

• 负载均衡：自动平衡各个线程的负载，绝不让 CPU 闲置。

---

四、 避坑指南（面试加分项）

最后，一定要补上“什么时候不能用”，体现你的实战经验：

“虽然 Fork/Join 听起来很牛，但在实际业务中，我严禁用它来处理 IO 密集型任务（比如读数据库、调 RPC）。

为什么？ 因为 Fork/Join 的所有线程都是守护线程，且默认线程数等于 CPU 核心数。一旦任务里有阻塞 IO，线程卡住，又没有多余的线程来补位，整个 CPU 算力就浪费了，甚至导致系统吞吐量暴跌。 IO 密集型任务，请老老实实使用 ThreadPoolExecutor！”