Skip to content

2.4-13 CompletableFuture 与异步编排 ​

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

  • 题型:原理 / 场景 / 排查

  • 一句话结论:CompletableFuture = Future + 函数式编排,回答两个问题:任务在哪个线程跑(有没有传 Executor)和依赖怎么串(CompletionStage)。async 方法不传 Executor 默认走 ForkJoinPool.commonPool,阻塞任务会打满它;异常沿依赖链传播,不 join/get 不处理就会被静默吞掉;orTimeout 只让 future 超时完成,不中断底层任务;简单扇出聚合用 CF,复杂背压/重试用 Reactor,JDK 21 虚拟线程下同步写法往往更简单。

  • 分层要点:

    1. 先分清两套语义:CompletableFuture 同时实现 Future(阻塞 get、有限 cancel)和 CompletionStage(回调式组合)。它不是线程池,只是任务句柄 + 依赖图;真正决定在哪跑的是构造时传入的 Executor。supplyAsync/runAsync 创建源头,thenXxx 挂后续,整个链可以没有任何线程池——非 async 回调就在完成线程上跑。
    2. 内部结构决定了行为:每个 CF 有 result(正常值或 AltResult 包装的异常)和一个 stack(后进先出的 Completion 节点链)。完成时 CAS 写入 result,再 postComplete() 逐个弹出依赖节点执行 tryFire。理解了这一点,就能解释“回调为什么在这个线程执行”“异常为什么沿链传播”“已完成的 future 为什么立即执行回调”。
    3. 回调在哪个线程执行:thenApply/thenAccept/thenRun/thenCompose 等非 async 方法,如果 future 尚未完成,回调在“完成它的那个线程”上执行;如果调用时已完成,则在调用线程上执行。thenXxxAsync 在指定 Executor 上执行,未指定则用 commonPool。thenCombine 在后完成的那个 future 的完成线程上触发。生产含义:RPC/Netty 线程完成 future 后,若直接挂 thenApply 做重活,会把业务逻辑跑在 IO 线程上。
    4. 组合操作分五类:转换 thenApply;消费 thenAccept/thenRun;扁平化 thenCompose(回调返回 CompletionStage);合并 thenCombine/thenAcceptBoth/runAfterBoth;二选一 applyToEither/acceptEither/runAfterEither;聚合 allOf/anyOf。allOf 返回 CompletableFuture<Void>,要逐个 join 取结果;任一任务异常时 allOf 会提前异常完成,且不会取消其他任务。anyOf 返回第一个完成的(可能是异常)。
    5. 异常语义:异常以 AltResult 沿链传播,后续正常回调被跳过。exceptionally 只处理异常并恢复;handle 同时拿到结果和异常、可转换;whenComplete 只观察、不改变结果(但回调自己抛异常会覆盖结果)。join() 抛 unchecked 的 CompletionException,get() 抛 ExecutionException/InterruptedException。没有人 join/get 也没有 handler 的异常会被静默丢弃,这是异步代码最隐蔽的坑。
    6. 线程池与上下文:async 未传 Executor 时默认 commonPool,并行度默认是 CPU 核数 - 1、线程是 daemon;阻塞 IO 会占满它,连带拖垮 parallelStream、其他 CF 默认异步任务。生产必须显式传有界、可命名、可观测、有拒绝策略的业务线程池,并按下游做隔离(bulkhead)。MDC、ThreadLocal、事务、SecurityContext、RequestContextHolder 不会自动跨线程传播(2.4-8、2.4-11);Spring @Async 也受代理自调用限制(3.1-5)。
    7. 超时、取消与边界:JDK 9 的 orTimeout 在超时后让 future 以 TimeoutException 完成,但不会中断底层任务;completeOnTimeout 给默认值;cancel 只取消该 CF 本身,不传播到上游任务,依赖它的 stage 收到 CancellationException。CF 没有内置重试、背压、限流;嵌套返回 CF 时要用 thenCompose 而不是 thenApply,否则得到 CompletableFuture<CompletableFuture<T>>。
    8. 选型与工程实践:扇出-聚合(并行调多个 RPC)、超时降级、回调编排适合 CF;流式处理、强背压、复杂重试/熔断用 Reactor/RxJava;JDK 21 虚拟线程 + 结构化并发下,同步阻塞代码往往更直观。落地规范:所有 async 都传命名线程池;每个外部调用有超时;join/get 有兜底;异常必须被观察;返回 CF 的 API 要说明线程池和异常语义;单测用可控 Executor(如 Runnable::run)避免随机调度。
  • 图/流程:

text
依赖图(转换 / 扁平化 / 合并 / 聚合):

  supplyAsync(A) ──thenApply──► A'
                        └──thenCompose──► B ──thenApply──► B'
  supplyAsync(C) ─────────────────────────┘
                                  thenCombine ──► (B', C')

  allOf(f1, f2, f3) ──► CompletableFuture<Void>
      └─ 需要再 f1.join() / f2.join() / f3.join() 取结果
  anyOf(f1, f2, f3) ──► 第一个完成的(可能是异常)
text
回调执行线程(非 async):

  future 未完成时:
    IO 线程完成 future ──postComplete──► 执行 thenApply 回调
    (回调跑在 IO 线程上,重活会阻塞 IO)

  future 已完成时:
    调用线程调用 thenApply ──► 立即在调用线程执行

  async:
    thenApplyAsync(fn, executor) ──► executor 线程执行
    不传 executor ──► ForkJoinPool.commonPool
text
异常传播:

  supplyAsync(抛异常)
    → result = AltResult(exception)
    → thenApply 被跳过
    → thenAccept 被跳过
    → exceptionally(e -> fallback) 恢复
    → 或者一路传播到 join(),抛 CompletionException

  没人观察:异常静默丢失(没有 UncaughtExceptionHandler)
text
扇出-聚合(并行 RPC):

  请求线程
    ├─ supplyAsync(userRpc, pool)   ─┐
    ├─ supplyAsync(orderRpc, pool)  ─┼─ allOf(...).orTimeout(500ms)
    └─ supplyAsync(couponRpc, pool) ─┘
                                      │
                           join + 逐项取结果 / 异常降级
                                      ▼
                                  组装响应

  注意:allOf 任一失败会提前异常完成,其他任务仍在跑;
        每个 future 自己也要有超时/降级。
text
同池死锁(经典):

  executor = 单线程池
  executor.submit(() -> {
      CompletableFuture f = CompletableFuture.supplyAsync(task, executor);
      return f.join();        // 占用唯一线程等待另一个任务
  });                         // 另一个任务永远排不上 → 死锁
  • 版本/源码锚点:

    • JDK 8:java.util.concurrent.CompletableFuture(Doug Lea),CompletionStage;supplyAsync/runAsync/thenApply/thenCompose/thenCombine/allOf/anyOf/exceptionally/handle/whenComplete。
    • JDK 9:orTimeout、completeOnTimeout、copy、minimalCompletionStage、delayedExecutor、newIncompleteFuture;ASYNC_POOL 统一默认执行器。JDK 8 在 commonPool 并行度为 1 时的默认异步行为与后续版本不同,按实际版本验证。
    • JDK 12:exceptionallyAsync、exceptionallyCompose、exceptionallyAsync 的 Executor 重载。
    • JDK 21:虚拟线程正式(JEP 444),Executors.newVirtualThreadPerTaskExecutor() 可作为 CF 的 Executor;结构化并发仍为 preview。
    • 源码:CompletableFuture 内部 result、stack、AltResult、Completion、UniApply、BiApply、UniCompose、AndBiRelay、postComplete、encodeThrowable、ASYNC_POOL;ForkJoinPool.commonPool();ThreadPoolExecutor 的队列/拒绝策略。
    • Spring:@Async 返回 CompletableFuture,依赖 AsyncTaskExecutor;自调用失效见 3.1-5。
  • API 分类表:

类别方法返回值说明
创建supplyAsync / runAsyncCF<T> / CF<Void>异步执行,可传 Executor
转换thenApplyCF<U>同步执行回调
转换(异步)thenApplyAsyncCF<U>在 Executor / commonPool 执行
消费thenAccept / thenRunCF<Void>只要结果 / 不要结果
扁平化thenComposeCF<U>回调返回 CompletionStage
合并thenCombineCF<V>两个结果合并
二选一applyToEitherCF<U>任一完成即可
聚合allOf / anyOfCF<Void> / CF<Object>全部 / 任一
异常exceptionally / handle / whenCompleteCF<T>恢复 / 转换 / 观察
超时orTimeout / completeOnTimeoutCF<T>超时异常 / 默认值
获取join / getTunchecked / checked
  • thenApply / thenCompose / thenCombine 对比:
方法回调形态结果典型场景
thenApplyT -> UCF<U>结果转换、映射
thenComposeT -> CompletionStage<U>CF<U>(扁平)串行依赖,下一步本身异步
thenCombine(T, U) -> VCF<V>并行两个源,结果合并
thenAcceptBoth(T, U) -> voidCF<Void>并行两个源,消费结果
runAfterBoth() -> voidCF<Void>两个源都完成后再执行
  • 同步回调 vs async 回调:
方法未完成时执行线程已完成后调用默认 Executor
thenApply完成 future 的线程调用线程无
thenApplyAsync(fn)指定 Executor指定 ExecutorcommonPool
thenApplyAsync(fn, pool)poolpool显式传入
thenCompose完成 future 的线程调用线程无
thenAccept完成 future 的线程调用线程无
  • 异常 API 对比:
API触发时机能否恢复能否改结果常见误用
exceptionally仅异常能能只处理直接异常,忽略上游链
handle正常/异常都触发能能在正常分支忘记返回原值
whenComplete正常/异常都触发不能(可再抛)不能以为能吞掉异常
join阻塞等待否否无超时、异常未捕获
get阻塞等待否否不处理 InterruptedException
  • 线程池选择与常见坑:
场景推荐注意
CPU 密集ForkJoinPool / 固定大小 ThreadPoolExecutor不要用 commonPool 跑阻塞
阻塞 IO / RPC独立有界线程池,按下游隔离命名、队列、拒绝策略、监控
请求级 fan-out独立池 + 信号量 + 超时防止打满下游与线程池
大量阻塞 IO(JDK 21+)newVirtualThreadPerTaskExecutor仍需限制下游连接数
流式/背压Reactor/RxJavaCF 无内置背压
单测Runnable::run 或同步 Executor避免随机调度导致 flaky
  • 常见坑清单:
现象根因处理
任务偶发不执行/结果没等到没 join/get,主线程提前结束明确等待或返回给框架
异常无声无息无人观察异常链尾 exceptionally/handle 或 join
线上卡顿/RT 抖动非 async 回调跑在 IO 线程上重活改 thenApplyAsync(fn, pool)
commonPool 被打满supplyAsync 未传 Executor 跑阻塞显式传业务线程池
线程池耗尽后死锁同池提交依赖任务并 join拆分池或避免嵌套等待
超时后下游仍在跑orTimeout 不中断任务下游客户端超时 + 取消/熔断
拿到 CF<CF<T>>用 thenApply 返回 CF改 thenCompose
allOf 没拿到结果只 allOf(...).join()逐个 join 取每个 future
allOf 早失败任一异常提前完成每个 future 单独降级
MDC/事务丢失跨线程不传播上下文显式传递或装饰器包装
@Async 不生效自调用/同类调用/非 Bean拆 Bean/自注入(3.1-5)
单测偶发失败调度顺序不确定用同步 Executor / 显式完成
  • 深挖点(面试官常追的 6 个):

    1. CompletableFuture 内部怎么完成一次回调:完成时先 CAS 写 result,再 postComplete() 从 stack 顶部弹出 Completion 节点,逐个 tryFire;每个节点是 UniApply/BiApply/UniCompose 等具体子类,内部再把自己的结果传给下游。这个 LIFO 栈结构解释了回调顺序、完成线程执行、以及为什么已完成的 future 会立即触发。
    2. 回调到底在哪个线程跑:非 async 方法在“完成该 future 的线程”执行;若调用时已完成,则在调用线程执行。async 方法在指定 Executor 执行,未指定用 commonPool。thenCombine 在后完成的那个源上触发。生产上最常见的错误是把耗时逻辑挂在非 async 回调上,结果跑在 Netty/RPC 的 IO 线程里,拖慢整个事件循环。
    3. thenApply 与 thenCompose 的本质区别:thenApply 是 map,回调返回普通值,得到 CF<U>;thenCompose 是 flatMap,回调返回 CompletionStage<U>,得到 CF<U>。用错会得到嵌套 CF,调用方还得再解一层;串行异步依赖(第二个调用依赖第一个结果)必须用 thenCompose。
    4. 异常为什么会“消失”:CF 没有全局未处理异常钩子,异常只是存进 result,沿链传播;如果整条链既不 join/get,也没有 exceptionally/handle/whenComplete,就没有任何人观察它。allOf 在任一子任务失败时会提前异常完成,但其他任务继续跑,若只 join 了 allOf 而未逐个检查,也会丢信息。
    5. commonPool 为什么危险:它是 JVM 全局共享的 ForkJoinPool,并行度默认 CPU-1,Worker 是 daemon,被 parallelStream、CF 默认 async、parallelSort 共用。一旦有阻塞任务占满 worker,其他使用 commonPool 的代码全部排队;ForkJoinPool 的补偿只对 ManagedBlocker 生效,普通阻塞不会自动扩容。所以阻塞任务必须用独立线程池。
    6. 超时、取消与虚拟线程的边界:orTimeout 只是让 CF 以 TimeoutException 完成,底层 RPC 不会被中断;cancel 也只影响 CF 自身,不传播到上游。真正的超时要靠下游客户端(HTTP/DB/RPC)设置连接/读超时并配合熔断。JDK 21 虚拟线程下,newVirtualThreadPerTaskExecutor() 可以作为 CF 的 Executor,但虚拟线程不改变“下游连接数是硬上限”这一事实,仍要信号量/连接池限流。
  • 追问链:

    1. CompletableFuture 是什么? → JDK 8 的异步编排工具,实现 Future + CompletionStage,支持回调和组合。
    2. 它和 Future 的区别? → Future 只能阻塞 get 和有限取消;CF 支持链式回调、组合、异常处理和超时。
    3. 它是线程池吗? → 不是,只是任务句柄;线程由构造时传入的 Executor 决定。
    4. supplyAsync 和 runAsync 区别? → 前者有返回值,后者无返回值。
    5. 不传 Executor 用哪个池? → ForkJoinPool.commonPool。
    6. commonPool 并行度多少? → 默认 CPU 核数 - 1,线程是 daemon。
    7. commonPool 有什么风险? → 全局共享,阻塞任务会占满 worker,拖垮 parallelStream 和其他 CF。
    8. thenApply 在哪个线程执行? → future 未完成时在完成它的线程;已完成时在调用线程。
    9. thenApplyAsync 在哪个线程执行? → 指定 Executor;未指定用 commonPool。
    10. 这个区别有什么生产影响? → 非 async 回调可能跑在 IO 线程上,重活会阻塞事件循环。
    11. thenApply 和 thenCompose 区别? → map vs flatMap;后者回调返回 CompletionStage,避免嵌套。
    12. thenApply 返回 CF 会怎样? → 得到 CF<CF<T>>,需要再解一层。
    13. thenCombine 干什么? → 等两个源都完成,把两个结果合并。
    14. allOf 返回什么? → CompletableFuture<Void>,要逐个 join 取结果。
    15. allOf 有异常会怎样? → 任一失败会提前异常完成,其他任务不取消。
    16. anyOf 返回什么? → 第一个完成的 future 的结果,可能是异常。
    17. 异常怎么传播? → 存进 AltResult 沿链传播,正常回调被跳过。
    18. exceptionally 和 handle 区别? → 前者只处理异常,后者正常/异常都处理并可转换。
    19. whenComplete 能吞异常吗? → 不能,它只观察;回调自己抛异常会覆盖结果。
    20. join 和 get 区别? → join 抛 unchecked CompletionException;get 抛 checked ExecutionException。
    21. 异常会被静默吞掉吗? → 会,没人 join/get 也没 handler 就没人观察。
    22. 怎么避免吞异常? → 链尾加 exceptionally/handle,或统一在边界 join 并记录。
    23. orTimeout 会中断任务吗? → 不会,只让 CF 以 TimeoutException 完成,底层任务继续跑。
    24. completeOnTimeout 干什么? → 超时时用默认值完成。
    25. cancel 会取消上游任务吗? → 不会,只取消 CF 自身,依赖 stage 收到 CancellationException。
    26. 真正的超时怎么做? → 下游客户端设连接/读超时 + 熔断 + CF 兜底。
    27. 为什么会有 CF<CF<T>>? → 用 thenApply 返回了 CompletionStage,应该用 thenCompose。
    28. MDC/ThreadLocal 会传播吗? → 不会,跨线程要显式传递或装饰器包装。
    29. 事务会传播到异步线程吗? → 不会,Spring 事务绑定线程,异步线程需独立事务或编程式事务。
    30. SecurityContext 会传播吗? → 不会,需要显式传递或装饰器。
    31. @Async 为什么可能不生效? → 自调用、同类调用、非 Spring Bean、未开 @EnableAsync。
    32. 怎么给 CF 指定线程池? → supplyAsync(fn, executor)、thenApplyAsync(fn, executor)。
    33. 线程池怎么配? → 有界队列、命名、拒绝策略、监控,按下游隔离。
    34. 同池嵌套等待会怎样? → 单线程池里提交依赖任务再 join,会死锁;线程池满时同理。
    35. 怎么避免线程池死锁? → 拆分池、避免嵌套等待、用独立池做阻塞依赖。
    36. 扇出聚合怎么做? → 每个下游 supplyAsync + 独立池,allOf + 超时 + 逐项降级。
    37. 扇出要限流吗? → 要,信号量/连接池/批量控制,防止打满下游。
    38. CF 能做重试吗? → 没有内置,需要自己包装或改用 Reactor/Resilience4j。
    39. CF 有背压吗? → 没有,流式背压用 Reactor/RxJava。
    40. CF 和 Reactor 怎么选? → 简单扇出/回调用 CF;流式、强背压、复杂组合用 Reactor。
    41. 虚拟线程怎么配合 CF? → 作为 Executor 传入,或直接用同步代码 + 结构化并发。
    42. 虚拟线程能解决 CF 的什么问题? → 让阻塞代码更便宜,简化编排;但不解决下游限流和超时。
    43. 单测怎么测 CF? → 用同步 Executor、显式 complete、Awaitility 等,避免依赖真实调度。
    44. CompletableFuture 能替代线程池吗? → 不能,它是编排工具,底层仍需 Executor。
    45. 面试怎么总结? → 两套语义(Future + CompletionStage)→ 回调线程规则 → 组合方法 → 异常传播 → commonPool 与隔离 → 超时/取消/虚拟线程边界。
  • 生产案例/取舍(示例,替换成你的项目):

    • 详情页并行调用户、订单、优惠券三个 RPC,用 allOf 聚合;最初没设超时,某个下游抖动导致整页 RT 飙升;给每个 future 加 orTimeout + 降级后恢复。
    • supplyAsync 没传 Executor,阻塞 RPC 跑满 commonPool;parallelStream 和其他 CF 任务全部排队。改成独立业务线程池后恢复。
    • 在 Netty 回调里直接挂 thenApply 做 JSON 序列化和 DB 写,IO 线程被占满,QPS 上不去;改成 thenApplyAsync(fn, bizPool)。
    • 异步任务异常没人处理,日志里什么都没有,接口返回空数据;链尾补 exceptionally + 告警。
    • allOf(...).join() 后直接取结果,某个 future 失败时 join 抛异常、其他结果丢失;逐个 join 并单独降级。
    • thenApply 里又发了一个异步调用,得到 CF<CF<T>>,调用方忘记解包;改 thenCompose。
    • 用 orTimeout 做超时,以为下游调用被终止,实际 RPC 还在跑,连接被占满;补下游读超时 + 熔断。
    • 单线程池里提交两个互相等待的任务,压测时死锁;拆成两个池并去掉嵌套 join。
    • @Async 方法自调用,任务同步执行;拆 Bean 或自注入代理(3.1-5)。
    • 异步线程里读 RequestContextHolder/MDC 拿到 null,日志 traceId 丢失;用 TaskDecorator 或显式传上下文。
    • 异步线程里用 @Transactional,事务不生效,数据只写了一半;改成独立事务方法或编程式事务。
    • 请求线程提交异步任务后直接返回,JVM 退出/容器重启导致任务丢失;加优雅停机等待或持久化任务。
    • 取舍:CF 换非阻塞编排和更低延迟,代价是异常/线程池/上下文都更隐蔽;Reactor 换背压和流式组合,代价是学习曲线和调试成本;虚拟线程换同步写法的简单性,代价是仍需限流;独立线程池换隔离,代价是资源与运维成本。
  • 易错点:

    • 认为 CompletableFuture 是线程池,实际它只是任务句柄,线程由 Executor 决定。
    • 认为 supplyAsync 默认用业务线程池,实际默认 commonPool。
    • 认为 commonPool 会自动扩容补偿阻塞,实际普通阻塞不会,只有 ManagedBlocker 会。
    • 认为 thenApply 总在异步线程执行,实际未完成时在完成线程、已完成时在调用线程。
    • 认为 thenApplyAsync 不传 Executor 会用调用线程池,实际用 commonPool。
    • 认为 thenApply 和 thenCompose 可以互换,实际后者才扁平化。
    • 认为 thenApply 返回 CF 会自动解包,实际得到嵌套 CF。
    • 认为 allOf(...).join() 就能拿到所有结果,实际返回 Void,要逐个 join。
    • 认为 allOf 会等所有任务结束,实际任一失败可能提前异常完成。
    • 认为 allOf 失败会取消其他任务,实际其他任务继续跑。
    • 认为 anyOf 只返回正常结果,实际也可能返回异常。
    • 认为 whenComplete 能吞异常,实际不能。
    • 认为 handle 只在异常时执行,实际正常/异常都执行。
    • 认为 exceptionally 能捕获链上所有异常,实际只处理到达它的异常,位置很关键。
    • 认为没人 join 的异常也会打日志,实际会被静默丢弃。
    • 认为 orTimeout 会中断底层任务,实际不会。
    • 认为 cancel 会取消上游任务,实际只取消 CF 自身。
    • 认为 get() 不需要处理中断,实际会抛 InterruptedException。
    • 认为 join() 抛 checked 异常,实际抛 unchecked CompletionException。
    • 认为 MDC/ThreadLocal 会自动传播到异步线程,实际不会。
    • 认为 Spring 事务会传播到异步线程,实际不会。
    • 认为 @Async 加在同类方法上会生效,实际自调用绕过代理。
    • 认为 CF 内置重试和背压,实际没有。
    • 认为虚拟线程能让阻塞任务无限扩展,实际仍受下游连接数限制。
    • 认为 commonPool 是虚拟线程调度器,实际两者不是一回事。
    • 认为单测里 CF 一定按顺序执行,实际调度不确定,需要同步 Executor。
    • 认为 CF 能替代线程池管理,实际队列/拒绝/监控仍要靠线程池。
    • 认为异步一定比同步快,实际小任务/低并发下同步更简单,异步有调度和上下文成本。
    • 认为超时设置了就安全,实际还要配合下游超时、熔断和限流。
  • 30 秒口述稿:

CompletableFuture 是 Future 加函数式编排,回答两件事:任务在哪个线程跑、依赖怎么串。非 async 回调在完成 future 的线程上执行,已完成的则在调用线程;async 不传 Executor 默认 commonPool,阻塞任务会打满它,所以生产要传独立的有界线程池。组合上用 thenApply 做转换、thenCompose 做扁平化、thenCombine 合并、allOf/anyOf 聚合;allOf 返回 Void,要逐个 join,而且任一失败会提前异常完成。异常沿链传播,没人 join 或处理就会被静默吞掉;orTimeout 只让 future 超时,不中断底层任务。简单扇出聚合用 CF,复杂背压用 Reactor,JDK 21 虚拟线程下同步写法更省心。

  • 3 分钟展开顺序:结论(Future + CompletionStage 两套语义)→ 内部 result/stack/postComplete → 回调执行线程规则 → 组合方法分类(转换/扁平化/合并/聚合)→ 异常传播与 join/get 差异 → commonPool 的风险与线程池隔离 → 超时/取消/上下文传播 → 扇出聚合实践 → CF vs Reactor vs 虚拟线程 → 生产坑与取舍。