Skip to content

2.4-7 ForkJoinPool 与工作窃取 ​

所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.4-5、2.4-6、2.4-11、2.4-13

  • 题型:原理 / 对比 / 场景

  • 一句话结论:ForkJoinPool 是面向分治任务的线程池,每个 worker 有一个双端队列,自己从 top 端 LIFO 取任务,空闲 worker 从别人的 base 端 FIFO 窃取;它适合 CPU 密集、可递归拆分、任务粒度可控的场景,不适合阻塞 IO 或长任务,commonPool 被阻塞还会拖垮 parallelStream 和 CompletableFuture 的默认异步。

  • 分层要点:

    1. 定位与任务模型:ForkJoinPool 在 JDK 7 引入,核心是 ForkJoinTask 和 work-stealing。任务分三种:RecursiveAction 无返回值、RecursiveTask<V> 有返回值、CountedCompleter 用完成回调组织依赖。典型写法是 compute() 里判断阈值,未到阈值就 fork() 左右子任务,再 join() 合并;invoke() 等价于 fork + join,invokeAll() 批量 fork 后统一 join。
    2. 工作窃取的数据结构:每个 ForkJoinWorkerThread 有自己的 ForkJoinTask[] queue,用 base 和 top 两个指针维护双端队列。owner 线程从 top 端 push/pop,是 LIFO;空闲 worker 从 victim 的 base 端 steal,是 FIFO。LIFO 让 owner 优先处理刚拆出来的“热”任务,提升缓存局部性;FIFO 让 thief 偷最老的任务,减少和 owner 在 top 端的竞争。base/top 用 volatile + CAS 维护,scan 随机选 victim,stealCount 记录窃取次数。
    3. fork / join 的语义:fork() 把任务压入当前 worker 的队列,异步执行;join() 等待结果,如果任务还没完成,当前线程不会傻等,而可能去帮助执行其他任务(help-steal),避免递归分治里的线程饥饿和死锁。invoke() 是 fork + join 的简写;invokeAll() 先 fork 所有任务再逐个 join。ForkJoinTask 内部用 status 位记录 NORMAL/CANCELLED/EXCEPTIONAL 等状态,join 会把异常重新抛出,get 则包成 ExecutionException。
    4. 池的内部与 commonPool:ForkJoinPool 维护 workQueues、ctl(并行度/活跃数/总线程数等)、worker 工厂、异常处理器、外部提交队列。默认并行度是 CPU 核数;commonPool 的并行度通常是 availableProcessors() - 1(至少 1),可通过 java.util.concurrent.ForkJoinPool.common.parallelism 在首次使用前调整。commonPool 是全局共享的,parallelStream、CompletableFuture 的默认异步、Arrays.parallelSort 都可能用它;commonPool 线程是 daemon/innocuous 线程,不要依赖 ThreadLocal 或上下文。
    5. 阻塞与补偿:ForkJoinPool 假设任务短小、CPU 密集、尽量不阻塞。如果必须阻塞,可以用 ManagedBlocker + ForkJoinPool.managedBlock,池子可能临时补偿 worker;但补偿有上限,不能把 FJP 当 IO 池用。长阻塞、RPC、DB、文件 IO 应使用 ThreadPoolExecutor 或虚拟线程;在 commonPool 里阻塞会占满并行度,导致其他 parallelStream/CompletableFuture 任务排队。
    6. 使用与选型:任务粒度要调:太小 fork/join 开销大,太大没有并行度;典型做法是阈值 + 压测。asyncMode=true 让本地队列变 FIFO,适合事件式、非递归任务;默认 LIFO 适合分治。FJP 适合 CPU 密集的递归计算、批量数据处理、并行排序;TPE 适合独立任务、阻塞 IO、需要拒绝策略和队列控制的场景;虚拟线程适合高并发阻塞 IO,不是替代 FJP 做 CPU 并行。
  • 图/流程:

text
Worker A 的双端队列
  base                          top
   [T1] [T2] [T3] [T4] [T5]
    ▲                       ▲
    │ thief 从 base 偷      │ owner 从 top push/pop
    │(FIFO,偷最老的)      │(LIFO,处理刚拆出的)

Worker B 空闲 → 随机 scan 到 A → CAS base 偷走 T1
text
RecursiveTask.compute()
  if (任务足够小) return 直接计算;
  left.fork();          // 压入当前 worker 队列
  rightResult = right.compute();
  leftResult = left.join();  // 等待,必要时帮助执行其他任务
  return merge(leftResult, rightResult);
  • 版本/源码锚点:

    • JDK 7:ForkJoinPool、ForkJoinTask、RecursiveAction/RecursiveTask。
    • JDK 8:CountedCompleter、parallelStream、CompletableFuture 默认 commonPool;ForkJoinPool 内部 ctl/工作窃取实现成熟。
    • JDK 9+:ForkJoinPool 增加/完善 ManagedBlocker、饱和策略等能力;commonPool 仍全局共享。
    • JDK 21:虚拟线程适合阻塞 IO,ForkJoinPool 仍主要面向 CPU 密集分治。
  • 任务类型表:

类型返回值用途
RecursiveAction无原地计算、批量处理
RecursiveTask<V>有分治后合并结果
CountedCompleter无/回调多任务完成后再触发后续动作
  • ForkJoinPool vs ThreadPoolExecutor:
维度ForkJoinPoolThreadPoolExecutor
队列每个 worker 一个 deque通常一个共享 BlockingQueue
调度工作窃取,owner LIFO/thief FIFO队列 + worker 竞争
适合CPU 密集、递归分治独立任务、阻塞 IO、可控队列
阻塞任务不友好,需 ManagedBlocker/补偿可配合大池/队列,但仍要隔离
拒绝/队列控制较弱强,队列/拒绝策略丰富
典型parallelStream、并行排序Web 请求、RPC、异步任务
  • commonPool 使用表:
场景是否用 commonPool注意
parallelStream()默认是阻塞/慢任务会拖垮全局
CompletableFuture 默认异步默认是阻塞任务应传自定义 Executor
Arrays.parallelSort默认是CPU 密集,通常合适
自定义分治计算可自建 FJP隔离并行度和任务
RPC/DB/文件 IO不要用 TPE 或虚拟线程
  • 追问链:

    1. 工作窃取的核心思想? → 每个 worker 有自己的 deque,owner 从 top LIFO 取,空闲 worker 从别人 base FIFO 偷,减少竞争并自动负载均衡。
    2. 为什么 owner 用 LIFO、thief 用 FIFO? → owner 处理刚拆出的任务,缓存局部性好;thief 偷最老的任务,减少与 owner 在 top 端的冲突,也能偷到粒度较大的任务。
    3. ForkJoinPool 和 ThreadPoolExecutor 怎么选? → 递归分治、CPU 密集、任务短小用 FJP;独立任务、阻塞 IO、需要队列/拒绝策略用 TPE;高并发阻塞 IO 可考虑虚拟线程。
    4. fork、join、invoke 有什么区别? → fork 异步压入队列;join 等待结果并可能帮助执行其他任务;invoke 是 fork + join;invokeAll 批量 fork 再 join。
    5. join 为什么不会轻易死锁? → 等待时当前 worker 可能去帮助执行被依赖的任务(help-steal),而不是纯阻塞;但任务里做外部阻塞仍可能拖垮池。
    6. RecursiveTask 和 RecursiveAction 怎么选? → 需要返回合并结果用 RecursiveTask;只做原地计算/副作用用 RecursiveAction;有完成回调依赖用 CountedCompleter。
    7. commonPool 的并行度是多少? → 默认 availableProcessors() - 1(至少 1),可通过系统属性在首次使用前调整;它不是无限的。
    8. parallelStream 用什么线程池? → 默认 commonPool;在自定义 FJP 里提交的 parallelStream 会用当前池,否则共享全局 commonPool。
    9. CompletableFuture 默认用什么池? → 没有传 Executor 的 async 方法默认 commonPool;阻塞任务会占满它,应显式传自定义池。
    10. FJP 里可以阻塞吗? → 尽量不;必须阻塞时用 ManagedBlocker/managedBlock,池子可能补偿线程,但有上限,不能当 IO 池。
    11. asyncMode 有什么用? → true 时本地队列 FIFO,适合事件式、非递归任务;默认 LIFO 适合分治。
    12. 任务粒度怎么定? → 太小 fork/join 开销大,太大并行度不足;用阈值 + 压测,让每个子任务足够“重”但仍能拆出并行度。
    13. ForkJoinTask 异常怎么处理? → join 重新抛出 RuntimeException/Error,get 包成 ExecutionException;必要时用 isCompletedAbnormally/getException 检查。
    14. FJP 怎么监控? → getStealCount、getQueuedTaskCount、getActiveThreadCount、getRunningThreadCount、getPoolSize,配合 JFR/jstack 和任务耗时。
    15. commonPool 被阻塞会怎样? → 并行度被占满,parallelStream、CompletableFuture 默认异步、parallelSort 全部排队,表现为全局变慢;要做池隔离。
    16. FJP 适合虚拟线程吗? → FJP 主要用平台线程做 CPU 并行;虚拟线程适合阻塞 IO,不应把虚拟线程池化后塞进 FJP 当普通 worker。
    17. ForkJoinPool 能 shutdown 吗? → 自定义池可以 shutdown/shutdownNow/awaitTermination;commonPool 是全局共享的,不应依赖关闭它,应用生命周期内一直存在。
  • 生产案例/取舍(示例,替换成你的项目):

    • 用 parallelStream() 做批量远程调用,commonPool 并行度被慢 RPC 占满,导致其他异步任务排队;改成自定义线程池或虚拟线程,并限制并发。
    • 递归计算订单分片,阈值设得太小,fork/join 次数爆炸,CPU 花在调度上;调大阈值后吞吐提升。
    • 在 FJP 任务里做数据库查询,池子活跃线程长期被阻塞;改用 TPE/虚拟线程,FJP 只做 CPU 计算。
    • 用 CompletableFuture.supplyAsync 不传 Executor,默认 commonPool 被阻塞任务打满;显式传业务线程池后恢复。
    • asyncMode=true 用于事件式任务,避免 LIFO 导致旧事件长期得不到处理;分治任务仍用默认 LIFO。
    • 取舍:FJP 的自动负载均衡很强,但前提是任务短小、可拆分、非阻塞;一旦阻塞,工作窃取的优势会变成全局排队。
  • 易错点:

    • 把 ForkJoinPool 当成通用 IO 线程池。
    • 在 commonPool 里做 RPC/DB/文件 IO,拖垮 parallelStream 和 CompletableFuture。
    • 认为 join 一定阻塞当前线程;它可能帮助执行其他任务。
    • 认为工作窃取没有竞争;base/top 仍有 CAS 和缓存行竞争。
    • 任务拆得太细,fork/join 开销超过计算本身。
    • 任务拆得太大,只有一个 worker 干活,其他 worker 空闲。
    • 忽略 ForkJoinTask 异常,join 时才发现任务失败。
    • 认为 parallelStream 一定比 for 循环快;小数据量/阻塞任务反而更慢。
    • 在 commonPool 线程里依赖 ThreadLocal/上下文类加载器。
    • 把虚拟线程和 FJP 混为一谈:一个解决阻塞 IO 的线程成本,一个解决 CPU 并行的任务调度。
  • 30 秒口述稿:

ForkJoinPool 是面向分治的线程池,每个 worker 一个双端队列,owner 从 top 端 LIFO 取任务,空闲 worker 从别人 base 端 FIFO 窃取,从而自动负载均衡。任务用 RecursiveAction/RecursiveTask/CountedCompleter,fork 压队列,join 等待并可能帮助执行其他任务。它适合 CPU 密集、可递归拆分、短小任务;不适合阻塞 IO。commonPool 默认并行度是核数减一,parallelStream 和 CompletableFuture 默认都用它,阻塞会拖垮全局,所以要做池隔离。

  • 3 分钟展开顺序:结论(分治 + 工作窃取)→ worker deque 与 LIFO/FIFO → fork/join/invoke → 任务类型 → commonPool 与 parallelStream/CompletableFuture → 阻塞与 ManagedBlocker → FJP vs TPE → 粒度/异常/监控 → 生产坑与选型。