Appearance
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 虚拟线程下同步写法往往更简单。分层要点:
- 先分清两套语义:
CompletableFuture同时实现Future(阻塞get、有限cancel)和CompletionStage(回调式组合)。它不是线程池,只是任务句柄 + 依赖图;真正决定在哪跑的是构造时传入的Executor。supplyAsync/runAsync创建源头,thenXxx挂后续,整个链可以没有任何线程池——非 async 回调就在完成线程上跑。 - 内部结构决定了行为:每个 CF 有
result(正常值或AltResult包装的异常)和一个stack(后进先出的Completion节点链)。完成时 CAS 写入result,再postComplete()逐个弹出依赖节点执行tryFire。理解了这一点,就能解释“回调为什么在这个线程执行”“异常为什么沿链传播”“已完成的 future 为什么立即执行回调”。 - 回调在哪个线程执行:
thenApply/thenAccept/thenRun/thenCompose等非 async 方法,如果 future 尚未完成,回调在“完成它的那个线程”上执行;如果调用时已完成,则在调用线程上执行。thenXxxAsync在指定 Executor 上执行,未指定则用commonPool。thenCombine在后完成的那个 future 的完成线程上触发。生产含义:RPC/Netty 线程完成 future 后,若直接挂thenApply做重活,会把业务逻辑跑在 IO 线程上。 - 组合操作分五类:转换
thenApply;消费thenAccept/thenRun;扁平化thenCompose(回调返回CompletionStage);合并thenCombine/thenAcceptBoth/runAfterBoth;二选一applyToEither/acceptEither/runAfterEither;聚合allOf/anyOf。allOf返回CompletableFuture<Void>,要逐个join取结果;任一任务异常时allOf会提前异常完成,且不会取消其他任务。anyOf返回第一个完成的(可能是异常)。 - 异常语义:异常以
AltResult沿链传播,后续正常回调被跳过。exceptionally只处理异常并恢复;handle同时拿到结果和异常、可转换;whenComplete只观察、不改变结果(但回调自己抛异常会覆盖结果)。join()抛 unchecked 的CompletionException,get()抛ExecutionException/InterruptedException。没有人join/get也没有 handler 的异常会被静默丢弃,这是异步代码最隐蔽的坑。 - 线程池与上下文:
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)。 - 超时、取消与边界:JDK 9 的
orTimeout在超时后让 future 以TimeoutException完成,但不会中断底层任务;completeOnTimeout给默认值;cancel只取消该 CF 本身,不传播到上游任务,依赖它的 stage 收到CancellationException。CF 没有内置重试、背压、限流;嵌套返回 CF 时要用thenCompose而不是thenApply,否则得到CompletableFuture<CompletableFuture<T>>。 - 选型与工程实践:扇出-聚合(并行调多个 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.commonPooltext
异常传播:
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。
- JDK 8:
API 分类表:
| 类别 | 方法 | 返回值 | 说明 |
|---|---|---|---|
| 创建 | supplyAsync / runAsync | CF<T> / CF<Void> | 异步执行,可传 Executor |
| 转换 | thenApply | CF<U> | 同步执行回调 |
| 转换(异步) | thenApplyAsync | CF<U> | 在 Executor / commonPool 执行 |
| 消费 | thenAccept / thenRun | CF<Void> | 只要结果 / 不要结果 |
| 扁平化 | thenCompose | CF<U> | 回调返回 CompletionStage |
| 合并 | thenCombine | CF<V> | 两个结果合并 |
| 二选一 | applyToEither | CF<U> | 任一完成即可 |
| 聚合 | allOf / anyOf | CF<Void> / CF<Object> | 全部 / 任一 |
| 异常 | exceptionally / handle / whenComplete | CF<T> | 恢复 / 转换 / 观察 |
| 超时 | orTimeout / completeOnTimeout | CF<T> | 超时异常 / 默认值 |
| 获取 | join / get | T | unchecked / checked |
- thenApply / thenCompose / thenCombine 对比:
| 方法 | 回调形态 | 结果 | 典型场景 |
|---|---|---|---|
thenApply | T -> U | CF<U> | 结果转换、映射 |
thenCompose | T -> CompletionStage<U> | CF<U>(扁平) | 串行依赖,下一步本身异步 |
thenCombine | (T, U) -> V | CF<V> | 并行两个源,结果合并 |
thenAcceptBoth | (T, U) -> void | CF<Void> | 并行两个源,消费结果 |
runAfterBoth | () -> void | CF<Void> | 两个源都完成后再执行 |
- 同步回调 vs async 回调:
| 方法 | 未完成时执行线程 | 已完成后调用 | 默认 Executor |
|---|---|---|---|
thenApply | 完成 future 的线程 | 调用线程 | 无 |
thenApplyAsync(fn) | 指定 Executor | 指定 Executor | commonPool |
thenApplyAsync(fn, pool) | pool | pool | 显式传入 |
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/RxJava | CF 无内置背压 |
| 单测 | 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 个):
- CompletableFuture 内部怎么完成一次回调:完成时先 CAS 写
result,再postComplete()从stack顶部弹出Completion节点,逐个tryFire;每个节点是UniApply/BiApply/UniCompose等具体子类,内部再把自己的结果传给下游。这个 LIFO 栈结构解释了回调顺序、完成线程执行、以及为什么已完成的 future 会立即触发。 - 回调到底在哪个线程跑:非 async 方法在“完成该 future 的线程”执行;若调用时已完成,则在调用线程执行。async 方法在指定 Executor 执行,未指定用 commonPool。
thenCombine在后完成的那个源上触发。生产上最常见的错误是把耗时逻辑挂在非 async 回调上,结果跑在 Netty/RPC 的 IO 线程里,拖慢整个事件循环。 - thenApply 与 thenCompose 的本质区别:
thenApply是 map,回调返回普通值,得到CF<U>;thenCompose是 flatMap,回调返回CompletionStage<U>,得到CF<U>。用错会得到嵌套 CF,调用方还得再解一层;串行异步依赖(第二个调用依赖第一个结果)必须用thenCompose。 - 异常为什么会“消失”:CF 没有全局未处理异常钩子,异常只是存进
result,沿链传播;如果整条链既不join/get,也没有exceptionally/handle/whenComplete,就没有任何人观察它。allOf在任一子任务失败时会提前异常完成,但其他任务继续跑,若只join了allOf而未逐个检查,也会丢信息。 - commonPool 为什么危险:它是 JVM 全局共享的 ForkJoinPool,并行度默认 CPU-1,Worker 是 daemon,被
parallelStream、CF 默认 async、parallelSort共用。一旦有阻塞任务占满 worker,其他使用 commonPool 的代码全部排队;ForkJoinPool 的补偿只对ManagedBlocker生效,普通阻塞不会自动扩容。所以阻塞任务必须用独立线程池。 - 超时、取消与虚拟线程的边界:
orTimeout只是让 CF 以TimeoutException完成,底层 RPC 不会被中断;cancel也只影响 CF 自身,不传播到上游。真正的超时要靠下游客户端(HTTP/DB/RPC)设置连接/读超时并配合熔断。JDK 21 虚拟线程下,newVirtualThreadPerTaskExecutor()可以作为 CF 的 Executor,但虚拟线程不改变“下游连接数是硬上限”这一事实,仍要信号量/连接池限流。
- CompletableFuture 内部怎么完成一次回调:完成时先 CAS 写
追问链:
- CompletableFuture 是什么? → JDK 8 的异步编排工具,实现
Future+CompletionStage,支持回调和组合。 - 它和 Future 的区别? → Future 只能阻塞 get 和有限取消;CF 支持链式回调、组合、异常处理和超时。
- 它是线程池吗? → 不是,只是任务句柄;线程由构造时传入的 Executor 决定。
supplyAsync和runAsync区别? → 前者有返回值,后者无返回值。- 不传 Executor 用哪个池? →
ForkJoinPool.commonPool。 - commonPool 并行度多少? → 默认 CPU 核数 - 1,线程是 daemon。
- commonPool 有什么风险? → 全局共享,阻塞任务会占满 worker,拖垮 parallelStream 和其他 CF。
- thenApply 在哪个线程执行? → future 未完成时在完成它的线程;已完成时在调用线程。
- thenApplyAsync 在哪个线程执行? → 指定 Executor;未指定用 commonPool。
- 这个区别有什么生产影响? → 非 async 回调可能跑在 IO 线程上,重活会阻塞事件循环。
- thenApply 和 thenCompose 区别? → map vs flatMap;后者回调返回 CompletionStage,避免嵌套。
- thenApply 返回 CF 会怎样? → 得到
CF<CF<T>>,需要再解一层。 - thenCombine 干什么? → 等两个源都完成,把两个结果合并。
- allOf 返回什么? →
CompletableFuture<Void>,要逐个 join 取结果。 - allOf 有异常会怎样? → 任一失败会提前异常完成,其他任务不取消。
- anyOf 返回什么? → 第一个完成的 future 的结果,可能是异常。
- 异常怎么传播? → 存进
AltResult沿链传播,正常回调被跳过。 - exceptionally 和 handle 区别? → 前者只处理异常,后者正常/异常都处理并可转换。
- whenComplete 能吞异常吗? → 不能,它只观察;回调自己抛异常会覆盖结果。
- join 和 get 区别? →
join抛 uncheckedCompletionException;get抛 checkedExecutionException。 - 异常会被静默吞掉吗? → 会,没人 join/get 也没 handler 就没人观察。
- 怎么避免吞异常? → 链尾加
exceptionally/handle,或统一在边界 join 并记录。 - orTimeout 会中断任务吗? → 不会,只让 CF 以 TimeoutException 完成,底层任务继续跑。
- completeOnTimeout 干什么? → 超时时用默认值完成。
- cancel 会取消上游任务吗? → 不会,只取消 CF 自身,依赖 stage 收到 CancellationException。
- 真正的超时怎么做? → 下游客户端设连接/读超时 + 熔断 + CF 兜底。
- 为什么会有
CF<CF<T>>? → 用 thenApply 返回了 CompletionStage,应该用 thenCompose。 - MDC/ThreadLocal 会传播吗? → 不会,跨线程要显式传递或装饰器包装。
- 事务会传播到异步线程吗? → 不会,Spring 事务绑定线程,异步线程需独立事务或编程式事务。
- SecurityContext 会传播吗? → 不会,需要显式传递或装饰器。
@Async为什么可能不生效? → 自调用、同类调用、非 Spring Bean、未开@EnableAsync。- 怎么给 CF 指定线程池? →
supplyAsync(fn, executor)、thenApplyAsync(fn, executor)。 - 线程池怎么配? → 有界队列、命名、拒绝策略、监控,按下游隔离。
- 同池嵌套等待会怎样? → 单线程池里提交依赖任务再 join,会死锁;线程池满时同理。
- 怎么避免线程池死锁? → 拆分池、避免嵌套等待、用独立池做阻塞依赖。
- 扇出聚合怎么做? → 每个下游
supplyAsync+ 独立池,allOf+ 超时 + 逐项降级。 - 扇出要限流吗? → 要,信号量/连接池/批量控制,防止打满下游。
- CF 能做重试吗? → 没有内置,需要自己包装或改用 Reactor/Resilience4j。
- CF 有背压吗? → 没有,流式背压用 Reactor/RxJava。
- CF 和 Reactor 怎么选? → 简单扇出/回调用 CF;流式、强背压、复杂组合用 Reactor。
- 虚拟线程怎么配合 CF? → 作为 Executor 传入,或直接用同步代码 + 结构化并发。
- 虚拟线程能解决 CF 的什么问题? → 让阻塞代码更便宜,简化编排;但不解决下游限流和超时。
- 单测怎么测 CF? → 用同步 Executor、显式 complete、Awaitility 等,避免依赖真实调度。
- CompletableFuture 能替代线程池吗? → 不能,它是编排工具,底层仍需 Executor。
- 面试怎么总结? → 两套语义(Future + CompletionStage)→ 回调线程规则 → 组合方法 → 异常传播 → commonPool 与隔离 → 超时/取消/虚拟线程边界。
- CompletableFuture 是什么? → JDK 8 的异步编排工具,实现
生产案例/取舍(示例,替换成你的项目):
- 详情页并行调用户、订单、优惠券三个 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 换背压和流式组合,代价是学习曲线和调试成本;虚拟线程换同步写法的简单性,代价是仍需限流;独立线程池换隔离,代价是资源与运维成本。
- 详情页并行调用户、订单、优惠券三个 RPC,用
易错点:
- 认为 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 异常,实际抛 uncheckedCompletionException。 - 认为 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 虚拟线程 → 生产坑与取舍。