知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# CompletableFuture 异步编排实战 > 导读:本文从"用 `Future.get()` 把多个并行调用的结果一个个取回来,越写越像同步代码,而且一个接口慢了所有线程都堵着"这个具体痛点出发,把 CompletableFuture 的创建方式、串行编排、并行聚合、异常兜底、超时控制,以及默认线程池的隐患和生产踩坑逐项讲透,最后给出一个"多服务并行查询再聚合"的完整可运行示例。适合已经用过线程池和 Future、想把手写异步编排写得更稳的中级 Java 同学。 ## 一、先建立全局认知 ### Q:传统 Future 到底哪里不够用? A:结论先行——Future 只有"提交 + 阻塞取结果"两个动作,**不能组合、不能回调、异常会被藏起来、失败无法兜底**。它的定位是"异步结果的占位符",不是"编排工具"。 `Future` 接口(`java.util.concurrent.Future`)实际只有 5 个方法: ```text boolean cancel(boolean mayInterruptIfRunning) // 尝试取消 boolean isCancelled() // 是否已取消 boolean isDone() // 是否已完成(正常/异常/取消都算完成) V get() // 阻塞取结果,抛 InterruptedException/ExecutionException V get(long timeout, TimeUnit unit) // 带超时取结果,额外抛 TimeoutException ``` 痛点一条条说清: - **只能阻塞取(`get`)**:想拿结果就必须 `get()`,等于把异步又拉回同步。若在提交任务后立刻 `get()`,那和直接调用没有任何区别。 - **无法组合多个任务**:要让"接口 A 和接口 B 都完成后再执行 C",只能自己写 `CountDownLatch` + 阻塞等;要让"B 依赖 A 的结果",只能 `a.get()` 再提交 B,一路阻塞下去。 - **不能设置回调**:Future 没有"完成后自动执行某段逻辑"的能力,只能由调用方轮询 `isDone()` 或阻塞 `get()`。 - **异常可被"吞掉"**:任务抛出的异常被包进 `ExecutionException`,只有调用 `get()` 时才会暴露。如果你忘了 `get()`(比如只做异步提交),异常就**悄无声息地消失**了。 - **无法按任务做超时/兜底**:`get(timeout)` 只对"等结果"超时,超时后任务本身还在跑,也没有"失败了返回默认值"的机制。 一句话:**Future 解决的是"异步执行",没解决"异步编排"。** 一个具体的"痛"是什么样?看用 Future 做并行调用的典型写法: ```java // 两个不相关的调用,想并行发起 Future<String> a = pool.submit(() -> callA()); Future<String> b = pool.submit(() -> callB()); String ra = a.get(); // 阻塞取结果 String rb = b.get(); // 阻塞取结果 String merged = ra + rb; // 只能在调用线程里手动拼 ``` 问题不在于"能不能并行"(这里确实并行发起了),而在于**"结果怎么处理"没有回调和组合能力**:只能由调用线程逐个 `get` 出来手动拼。一旦业务变复杂(要兜底、要超时、要做异常转换),这些逻辑就全都堆在调用线程里,越写越像同步代码。这正是 `CompletableFuture` 要解决的核心问题。 ### Q:CompletableFuture 相比 Future 补了什么? A:结论先行——**CompletableFuture 在异步执行的基础上,补齐了"回调、编排、组合、异常处理、超时"五项能力**,把异步流程写成了可读的链式代码。 它实现了 `Future` 和 `CompletionStage` 两个接口: - 作为 `Future`:仍然有 `get()`/`cancel()`/`isDone()`,兼容老代码; - 作为 `CompletionStage`:提供几十个"阶段(stage)"方法,每个方法返回一个新的 `CompletableFuture`,从而支持链式拼接。 能力对照: | 能力 | Future | CompletableFuture | |---|---|---| | 异步执行 | 支持 | 支持 | | 阻塞取结果 | `get()` | `get()` / `join()` | | 完成后回调 | 无 | `thenAccept`/`thenRun`/`whenComplete` | | 结果转换 | 无 | `thenApply` | | 串联依赖(扁平化) | 无(会嵌套) | `thenCompose` | | 并行合并 | 无 | `thenCombine`/`thenAcceptBoth` | | 等多个/任一完成 | 无(手写 latch) | `allOf`/`anyOf` | | 异常兜底 | 无 | `exceptionally`/`handle` | | 超时 | `get(timeout)`(不终止任务) | `orTimeout`/`completeOnTimeout`(JDK 9+) | **为什么它能链式编排?** 关键是"每个阶段本身就返回 `CompletableFuture`"。内部用一个 `result` 字段记录"未完成 / 正常结果 / 异常",并维护一个回调栈:当上一阶段完成时,会把栈里登记的后续动作依次触发。所以 `thenXxx` 的语义是"登记一个'完成之后再做什么'的函数",而不是"立即执行"。理解这一点,才能理解后面 `thenApply` 和 `thenApplyAsync` 的执行线程差异。 ## 二、创建:supplyAsync / runAsync 与线程池选择 ### Q:supplyAsync 和 runAsync 怎么选? A:结论先行——**需要返回值用 `supplyAsync(Supplier<U>)`,不需要返回值用 `runAsync(Runnable)`**;两者的区别就是"有没有返回值",其它一致。 ```java import java.util.concurrent.*; public class CreateDemo { public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(4); // 有返回值:Supplier,结果类型由泛型推导 CompletableFuture<String> supply = CompletableFuture.supplyAsync(() -> { return "query-result"; }, pool); // 无返回值:Runnable,返回 CompletableFuture<Void> CompletableFuture<Void> run = CompletableFuture.runAsync(() -> { System.out.println("fire and forget"); }, pool); System.out.println(supply.join()); // query-result run.join(); // 等它跑完(Void) pool.shutdown(); // 已经知道结果的场景:直接构造一个已完成阶段(常用于测试或兜底) CompletableFuture<String> done = CompletableFuture.completedFuture("cached"); System.out.println(done.join()); // cached } } ``` 关键点与适用场景: - `supplyAsync` 适合"发起一个查询/计算并要结果";`runAsync` 适合"只触发的动作",如发消息、写日志、异步埋点。 - 两者都提供了一个 `Async` 重载接收 `Executor`。**生产环境必须优先用带 Executor 的重载**(原因见下一问)。 - `completedFuture(value)` 返回一个已经完成的阶段,常用于:短路已命中的缓存、单测中替换真实调用、以及给后续链路提供一个"初始阶段"。 - 注意 `runAsync` 的返回是 `CompletableFuture<Void>`,它**不能承载结果**,`join()` 返回 `null`。如果后面还要基于它的返回值编排,就该用 `supplyAsync`。 ### Q:不传 Executor 时用的是什么线程池?为什么不能依赖它? A:结论先行——**不传 Executor 时默认使用 `ForkJoinPool.commonPool()`(公共池)**。它是一个全局共享、大小受限的池,适合短小的 CPU 任务,**不适合承载阻塞的 IO 和大量业务调用**。 两个必须知道的细节: 1. **公共池是全局共享的**:同一个 JVM 里所有没传 Executor 的 `CompletableFuture`、并行流(`parallelStream`)都挤在同一个池里。你的一个慢任务会挤占别人的并行度。 2. **默认并行度很小**:公共池的并行度默认是 `Runtime.getRuntime().availableProcessors() - 1`(最少为 1),可通过系统属性 `java.util.concurrent.ForkJoinPool.common.parallelism` 调整。也就是说,一个 4 核机器上默认只有 3 个线程。如果你用默认池去发起 20 个阻塞的 HTTP 调用,第 4 个开始就会排队——**异步变成了串行**,而且拖慢整个 JVM 里其他依赖公共池的代码。 **为什么它默认这么小、还是用工作窃取?** 因为 ForkJoinPool 的设计目标是把"可拆分的 CPU 密集计算"跑满 CPU,"阻塞"从来不是它的场景。工作窃取能提高 CPU 利用率,但对"线程全被阻塞住"无能为力。 正确做法:**为 IO/业务类异步任务定义专属线程池**,并显式传入。 ```java import java.util.concurrent.*; public class CustomPoolDemo { // 为下游调用单独隔离一个线程池:核心 8、最大 16、有界队列、命名线程、可观测 private static final ThreadPoolExecutor BIZ_POOL = new ThreadPoolExecutor( 8, 16, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(200), r -> { Thread t = new Thread(r); t.setName("cf-biz-" + t.getId()); t.setDaemon(true); return t; }, new ThreadPoolExecutor.CallerRunsPolicy() // 队列满时由提交线程执行,形成背压 ); public static CompletableFuture<String> asyncQuery(String param) { // 显式指定线程池,绝不裸用 commonPool return CompletableFuture.supplyAsync(() -> doQuery(param), BIZ_POOL); } private static String doQuery(String param) { return "result-of-" + param; } } ``` 关键点:用 `ThreadPoolExecutor` 而不是 `Executors` 的工厂方法,能显式控制队列容量(避免无界队列 OOM)和拒绝策略(形成背压而不是静默丢弃);给线程命名便于 `jstack` 定位;把异步调用与"其它依赖公共池的代码"隔离,避免互相拖累。 ## 三、串行编排:thenApply / thenCompose / thenAccept / thenRun ### Q:thenApply、thenAccept、thenRun 三者的区别是什么? A:结论先行——区别就在"**要不要上一步的结果**"和"**要不要给下一步结果**"两个维度上: | 方法 | 入参 | 返回 | 用不用上一步结果 | 有没有新结果 | |---|---|---|---|---| | `thenApply` | `Function<T,U>` | `CompletableFuture<U>` | 用(拿到 T) | 有(产出 U) | | `thenAccept` | `Consumer<T>` | `CompletableFuture<Void>` | 用(拿到 T) | 无 | | `thenRun` | `Runnable` | `CompletableFuture<Void>` | 不用 | 无 | 选型:**要转换结果用 `thenApply`;要消费结果(打印、入库、发消息)用 `thenAccept`;完全不关心结果、只是"接在后面做件事"用 `thenRun`。** ```java import java.util.concurrent.*; public class SerialChainDemo { public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(4); CompletableFuture<String> chain = CompletableFuture .supplyAsync(() -> "42", pool) // 阶段1:产出 "42" .thenApply(s -> Integer.parseInt(s)) // 阶段2:String -> Integer .thenApply(n -> n * 2) // 阶段3:Integer -> Integer(84) .thenApply(n -> "value=" + n); // 阶段4:Integer -> String System.out.println(chain.join()); // value=84 // thenAccept:消费结果,不产出 chain.thenAccept(v -> System.out.println("consume: " + v)); // thenRun:不关心结果,只关心"上一步做完之后" chain.thenRun(() -> System.out.println("chain done")); // 注意:thenAccept / thenRun 的返回值都是 CompletableFuture<Void>, // 若要等它们执行完,需要 join 它们的返回值 chain.thenRun(() -> System.out.println("after all")).join(); pool.shutdown(); } } ``` 关键点:`thenXxx` 是**串行**的——下一步一定在上一阶段`正常完成`之后才会执行;如果上一阶段异常结束,后面的 `thenApply`/`thenAccept`/`thenRun` 会被**直接跳过**,异常继续往下传递,直到遇到 `exceptionally`/`handle` 为止(详见第五节)。这一点非常重要:你以为的"thenAccept 一定会执行"在异常路径下并不成立。 ### Q:thenCompose 和 thenApply 的区别?为什么需要 thenCompose? A:结论先行——**`thenApply` 用于"普通转换",`thenCompose` 用于"转换结果本身又是一个 CompletableFuture"**,也就是用来**扁平化嵌套**。 对比看差异: ```java // thenApply:函数返回普通值 U,得到 CF<U> CompletableFuture<String> a = CompletableFuture .supplyAsync(() -> "user-1") .thenApply(id -> "profile-of-" + id); // CF<String> // 反例:函数返回的是 CF<U>,用 thenApply 会得到 CF<CF<U>> —— 嵌套了 CompletableFuture<CompletableFuture<String>> nested = CompletableFuture .supplyAsync(() -> "user-1") .thenApply(id -> asyncLoadProfile(id)); // CF<CF<String>>,不想要 // 正解:thenCompose 会把里层展开,得到 CF<String> CompletableFuture<String> flat = CompletableFuture .supplyAsync(() -> "user-1") .thenCompose(id -> asyncLoadProfile(id)); // CF<String> ``` 配合一个真实的"依赖式调用"示例:先拿 userId,再拿它的订单。 ```java import java.util.concurrent.*; public class ComposeDemo { public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(4); CompletableFuture<String> order = CompletableFuture .supplyAsync(() -> queryUserId("token-abc"), pool) // 第一步:查 userId .thenCompose(userId -> // 用 userId 串第二步 CompletableFuture.supplyAsync(() -> queryOrder(userId), pool)); System.out.println(order.join()); // 打印订单 pool.shutdown(); } private static String queryUserId(String token) { return "u-1001"; } private static String queryOrder(String userId) { return "order-of-" + userId; } } ``` 预期行为:两步串行执行,第二步的输入是第一步的输出,最终拿到扁平的 `CompletableFuture<String>`。 **适用与不适用**:`thenCompose` 专门用于"上一步结果决定下一步异步调用"的链式依赖;如果下一步不是异步(没有返回 `CompletableFuture`),用 `thenApply` 就够了。误用 `thenApply` 会得到 `CF<CF<T>>`,你会不得不再 `join()` 一次,反而丢掉了链式编排的意义。 ### Q:带 Async 后缀和不带有什么区别?什么时候必须用 Async? A:结论先行——**不带 `Async` 的回调,可能由"完成上一阶段的那个线程"或"调用 `thenXxx` 的那个线程"来执行;带 `Async` 的回调则一定被提交到指定线程池(不指定则公共池)执行。** 具体规则(这是面试高频追问点): - **不带 `Async`(如 `thenApply`)**:如果上一阶段在你登记回调时**已经完成**,回调就在**当前线程**同步执行;如果尚未完成,回调由**完成上一阶段的线程**执行。 - **带 `Async`(如 `thenApplyAsync`)**:回调被包装成一个任务,提交到 `Executor`(默认 `ForkJoinPool.commonPool()`)执行,与上一阶段在哪个线程完成无关。 ```java // 观察执行线程 CompletableFuture<String> f = CompletableFuture.supplyAsync(() -> "x"); f.thenApply(v -> { System.out.println("thenApply 线程: " + Thread.currentThread().getName()); return v; }); f.thenApplyAsync(v -> { System.out.println("thenApplyAsync 线程: " + Thread.currentThread().getName()); return v; }).join(); ``` 关键结论与选型: - 在 `main` 里对"已经完成"的 future 调 `thenApply`,回调大概率跑在 `main` 线程;这就是"异步链里混进了同步代码"的原因。 - 如果回调里做**阻塞 IO 或耗时操作**,一定要用 `Async` 并传自己的业务线程池,避免占用上一阶段的工作线程甚至调用方线程。 - 如果回调只是**轻量转换**(拼字符串、取字段),用不带 `Async` 的版本可以减少一次线程切换,反而更快。 - **不要混用默认池**:`thenApplyAsync` 不传 Executor 会用 `commonPool`,又把任务丢回了公共池。要么统一传业务池,要么让回调保持轻量。 ## 四、并行聚合:thenCombine / thenAcceptBoth / allOf / anyOf ### Q:两个并行任务怎么合起来? A:结论先行——**要合并两个结果并产出新值用 `thenCombine`;只想消费两个结果不产出用 `thenAcceptBoth`;只想在两者都完成后做动作(不关心结果)用 `runAfterBoth`。** ```java import java.util.concurrent.*; public class CombineDemo { public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(4); CompletableFuture<String> userF = CompletableFuture.supplyAsync(() -> queryUser("u-1"), pool); CompletableFuture<String> orderF = CompletableFuture.supplyAsync(() -> queryOrder("u-1"), pool); // 合并两个结果,产出新值 CompletableFuture<String> merged = userF.thenCombine( orderF, (user, order) -> user + " | " + order); System.out.println(merged.join()); // 只消费,不产出 userF.thenAcceptBoth(orderF, (user, order) -> System.out.println("consume both: " + user + "," + order)).join(); // 两个都完成后做动作,不关心结果 userF.runAfterBoth(orderF, () -> System.out.println("both done")).join(); pool.shutdown(); } private static String queryUser(String id) { return "user:" + id; } private static String queryOrder(String id) { return "order:" + id; } } ``` 关键点:`thenCombine` 的合并是"两个都完成才触发",但**它不会主动让两个任务并行**——并行取决于任务提交时用的线程池是否有足够线程。上面两个 `supplyAsync` 提交到 4 线程的池,才会真正并行。 ### Q:allOf 和 anyOf 怎么用?为什么 allOf 拿不到结果? A:结论先行——**`allOf` 等全部完成,返回 `CompletableFuture<Void>`;`anyOf` 等任意一个完成,返回 `CompletableFuture<Object>`**。两者都只告诉你"完成状态",不直接给你每个任务的结果,所以结果要靠回各原始 future 去 `join()`。 `allOf` 的正确用法: ```java import java.util.*; import java.util.concurrent.*; import java.util.stream.Collectors; public class AllOfDemo { public static void main(String[] args) throws Exception { ExecutorService pool = Executors.newFixedThreadPool(4); List<String> keys = Arrays.asList("a", "b", "c", "d"); // 关键:把每个 CF 收集起来,allOf 之后再逐个 join 回结果 List<CompletableFuture<String>> futures = keys.stream() .map(k -> CompletableFuture.supplyAsync(() -> "value-" + k, pool)) .collect(Collectors.toList()); CompletableFuture<Void> all = CompletableFuture.allOf( futures.toArray(new CompletableFuture[0])); // all 完成时,各 future 一定已完成,此时 join 不会阻塞 CompletableFuture<List<String>> result = all.thenApply(v -> futures.stream().map(CompletableFuture::join).collect(Collectors.toList())); System.out.println(result.join()); // [value-a, value-b, value-c, value-d] pool.shutdown(); } } ``` 关键点与陷阱: - **`allOf` 返回 `CF<Void>`,本身没有"结果列表"**。所以必须像上面这样保留原始 `futures` 集合,`allOf` 完成后再 `join()` 每个——此时它们都已完成,`join()` 不会阻塞。 - **`allOf` 是"一错全错"**:只要有一个任务异常,`allOf` 返回的 future 就以异常完成(completes exceptionally),`thenApply` 不会执行,对 `all` 的 `join()` 会抛 `CompletionException`。若希望"某个失败不影响整体",要在每个子任务上先做 `exceptionally` 兜底,再 `allOf`。 - `anyOf` 返回 `CF<Object>`:**谁先完成就用谁**,无论它是正常完成还是异常完成。所以如果第一个完成的任务抛了异常,`anyOf` 的结果就是异常,需要额外判断。`anyOf` 适合"多副本并发请求,取最快返回的那个"。 ```java // anyOf:多副本取最快(注意:失败也算"完成",需要自行判空/捕获) CompletableFuture<Object> fastest = CompletableFuture.anyOf( CompletableFuture.supplyAsync(() -> "replica-1", pool), CompletableFuture.supplyAsync(() -> "replica-2", pool)); System.out.println(fastest.join()); ``` ### Q:三个以上的任务怎么聚合?thenCombine 链式合并和 allOf 怎么选? A:结论先行——**两三个任务、需要"两两合并成一个结果"时用 `thenCombine` 链式合并;数量不定或较多(尤其任务来自集合)时用 `allOf` + 遍历 `join`**。两者都能并行,区别在"结果合并方式"和"可读性、扩展性"。 `thenCombine` 一次只能合并两个结果,三个任务就要嵌套两层,并需要一个中间载体: ```java // 三任务:先 a+b 合成中间值,再与 c 合成最终值 CompletableFuture<String> r = a.thenCombine(b, (x, y) -> x + "+" + y) // 中间结果 "x+y" .thenCombine(c, (xy, z) -> xy + "+" + z); // 最终 "x+y+z" ``` 而 `allOf` 不需要中间容器,任务数再多也是"收集 → 等待 → 遍历取结果": ```java // N 个任务(数量运行时才知道,来自集合) List<CompletableFuture<String>> fs = tasks.stream() .map(t -> CompletableFuture.supplyAsync(() -> handle(t), pool)) .collect(Collectors.toList()); List<String> results = CompletableFuture .allOf(fs.toArray(new CompletableFuture[0])) .thenApply(v -> fs.stream().map(CompletableFuture::join).collect(Collectors.toList())) .join(); ``` 选型对照: | 维度 | `thenCombine` 链式合并 | `allOf` + 遍历 join | |---|---|---| | 任务数量 | 固定、少(2~3 个) | 不定、较多 | | 结果合并 | 在合并函数里直接组装 | 先收集 future,再遍历取结果 | | 可读性 | 数量多时嵌套代码难读 | 列表化,整齐 | | 类型安全 | 泛型明确,编译期可检查 | 统一 `Object` 或各自 `join`,弱一些 | | 异常语义 | 任一分支异常都会中断合并链 | 同左(一错全错),需各自兜底 | **一句话**:任务数和类型"编译期就确定"用 `thenCombine`;任务来自集合、运行时才知道数量用 `allOf`。无论选哪个,都改变不了"是否真正并行由线程池决定"这一事实。 ## 五、异常、超时与生产实践 ### Q:exceptionally、handle、whenComplete 有什么差异? A:结论先行——**`exceptionally` 只在失败时触发并做兜底恢复;`handle` 无论成败都触发、可以产出新值;`whenComplete` 无论成败都触发但只做旁路动作(如记日志),不改变原结果。** | 方法 | 触发时机 | 入参 | 返回类型 | 能否改变结果/异常 | |---|---|---|---|---| | `exceptionally` | 仅异常 | `Throwable` | `CF<T>` | 能:返回兜底值 `T`,把异常"消化"掉 | | `handle` | 成功 + 异常 | `(T, Throwable)` | `CF<U>` | 能:总是产出新值 `U` | | `whenComplete` | 成功 + 异常 | `(T, Throwable)` | `CF<T>` | 不能:原结果/异常继续向下传递,除非它自己抛异常 | ```java import java.util.concurrent.*; public class ExceptionDemo { public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(2); // 1) exceptionally:失败时给默认值,链路可以继续 String v1 = CompletableFuture .supplyAsync(() -> { throw new RuntimeException("boom"); }, pool) .exceptionally(ex -> { System.out.println("exceptionally: " + ex.getClass().getSimpleName()); return "fallback"; }) .join(); System.out.println("v1=" + v1); // v1=fallback // 2) handle:成功或失败都走这里,产出新值 String v2 = CompletableFuture .<String>supplyAsync(() -> "ok", pool) .handle((res, ex) -> ex != null ? "err" : res + "-handled") .join(); System.out.println("v2=" + v2); // v2=ok-handled // 3) whenComplete:旁路记录,不影响结果,也不吞异常 String v3 = CompletableFuture .supplyAsync(() -> "done", pool) .whenComplete((res, ex) -> System.out.println("whenComplete: res=" + res + ", ex=" + ex)) .join(); System.out.println("v3=" + v3); // v3=done pool.shutdown(); } } ``` 选型: - 要"失败降级、返回默认值"→ `exceptionally`; - 要"统一出口,成功失败都返回同一种结构(如统一 Result 包装)"→ `handle`; - 要"只观测/打日志/清资源,不影响主链路"→ `whenComplete`。 **关键差异**:`whenComplete` 的返回值仍是 `CF<T>`,原异常不会被消化;如果你用它来"兜底",异常照旧抛出。很多人以为 `whenComplete` 能兜底,这是最常见的误解。 ### Q:超时怎么处理?orTimeout 和 completeOnTimeout 有什么区别? A:结论先行——**两者都在 JDK 9 引入**。`orTimeout` 超时后让 future 以 `TimeoutException` 异常完成;`completeOnTimeout` 超时后用给定值正常完成(兜底值)。 ```java import java.util.concurrent.*; public class TimeoutDemo { public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(2); // orTimeout:800ms 还没结果 → 以 TimeoutException 异常完成(被包进 CompletionException) CompletableFuture<String> slow = CompletableFuture .supplyAsync(() -> { sleep(2000); return "late"; }, pool) .orTimeout(800, TimeUnit.MILLISECONDS) .exceptionally(ex -> "timeout-fallback"); // 兜住超时 System.out.println(slow.join()); // timeout-fallback // completeOnTimeout:800ms 还没结果 → 用给定默认值正常完成 CompletableFuture<String> slow2 = CompletableFuture .supplyAsync(() -> { sleep(2000); return "late"; }, pool) .completeOnTimeout("default-value", 800, TimeUnit.MILLISECONDS); System.out.println(slow2.join()); // default-value pool.shutdown(); } private static void sleep(long ms) { try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } ``` 关键点与版本注意: - **`orTimeout`/`completeOnTimeout` 是 JDK 9+ 的 API**;如果项目还在 JDK 8,需要用 `ScheduledExecutorService` 手动实现:定时到了就调 `future.complete(defaultValue)` 或 `future.completeExceptionally(new TimeoutException())`。**需结合你的 JDK 版本确认可用性。** - 它们**让 future 提前"完成",但不会中断底层任务**。上面的 `sleep(2000)` 仍会跑完,只是结果被丢弃。所以配这类超时时,底层调用本身也要有超时(如 HTTP 客户端超时),否则线程还是被占着。 - `orTimeout` 的异常是 `TimeoutException`,`join()` 时被包成 `CompletionException`;用 `get()` 时被包成 `ExecutionException`。 ### Q:get() 和 join() 到底怎么选? A:结论先行——**两者都阻塞取结果,区别在异常类型:`get()` 抛受检异常、`join()` 抛非受检异常**。纯编排场景优先 `join()`;需要响应中断、或以 `Future` 接口引用时用 `get()`。 ```java CompletableFuture<String> f = CompletableFuture.supplyAsync(() -> { if (Math.random() > 0.5) throw new IllegalStateException("failed"); return "ok"; }); // get():受检异常,必须 try/catch 或向上声明 try { String v = f.get(); // 可能抛 InterruptedException / ExecutionException } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复中断标志 } catch (ExecutionException e) { Throwable cause = e.getCause(); // 真正的业务异常(如 IllegalStateException)在这里 } // join():非受检异常,调用更简洁 try { String v = f.join(); // 可能抛 CompletionException / CancellationException } catch (CompletionException e) { Throwable cause = e.getCause(); // 同样用 getCause() 拿根因 } ``` 差异对照: | 维度 | `get()` | `join()` | |---|---|---| | 声明异常 | `InterruptedException`、`ExecutionException`(受检) | `CompletionException`、`CancellationException`(非受检) | | 中断响应 | 会抛 `InterruptedException` | 不抛 `InterruptedException` | | 典型用法 | 需响应中断、或持有 `Future` 接口引用 | 纯 `CompletableFuture` 编排 | | 取根因 | `e.getCause()` | `e.getCause()` | 关键点: - 两者拿到的都是"被包装过的异常",**业务根因要通过 `getCause()` 取出**;`join()` 的场景下有时会再包一层 `CompletionException`,取值时要留意。 - `join()` 是运行时异常,在 lambda 里不会被迫写 try/catch,但**不代表可以不处理**:该在链路上用 `exceptionally`/`handle` 兜住,要么在最外层统一 catch。 - 如果方法签名返回的是 `Future<T>` 接口引用,那就只能调 `get()`——`join()` 是 `CompletableFuture` 特有的方法。 ### Q:生产上有哪些必踩的坑? A:结论先行——最危险的四类坑是:**异常被吞、用 `get()` 阻塞、线程上下文/ThreadLocal 丢失、线程池不隔离**。逐条给出"症状 → 原因 → 对策"。 1. **异常被静默吞掉** - 症状:任务明明失败,日志里什么都没有,业务像什么都没发生。 - 原因:`CompletableFuture` 里的异常只有被"终端操作"消费(`get()`/`join()`/`exceptionally`/`handle`)或显式查询时才会暴露。若你 `supplyAsync` 之后不接任何处理也不 `join`,异常就一直存在 future 里,无人知晓。 - 对策:每条链路都要有终点——要么 `exceptionally`/`handle` 统一兜底并打日志,要么对最终 future 调 `join()` 并捕获 `CompletionException`。做"fire-and-forget"的异步时,务必在链路末尾挂一个 `whenComplete` 记录异常。 2. **用 `get()` 阻塞,把异步写成同步** - 症状:接口耗时没有下降,线程数却涨了,还容易死锁。 - 原因:`get()` 是阻塞的;在异步线程池里再 `get()` 另一个 future,会"占着线程等线程",池子小的时候直接互相等死。 - 对策:优先用 `thenCompose`/`thenCombine` 做**非阻塞编排**,把"等结果"变成"登记回调"。确实需要阻塞时,用 `join()` 并只在最外层(如 Controller 出口)阻塞一次。 3. **ThreadLocal / 调用上下文丢失** - 症状:异步里打印的 traceId、登录用户、MDC 日志上下文全是空的。 - 原因:`thenXxxAsync` 的回调在**另一个线程**执行,而 `ThreadLocal` 是线程私有的;`InheritableThreadLocal` 只在线程创建时复制一次,线程池复用线程后也不可靠。 - 对策:在提交异步任务**之前**把上下文取出来,作为**显式参数**传进 lambda;或在自定义 `ThreadPoolExecutor` 里用可传递的上下文包装(如 TransmittableThreadLocal 之类的方案)。**不要**依赖隐式的 `ThreadLocal` 穿透异步线程池。 4. **线程池不隔离 / 裸用 commonPool** - 症状:某类异步任务变慢,拖垮了不相关的功能;或者整个应用的并行流一起变慢。 - 原因:默认 `ForkJoinPool.commonPool()` 全局共享且并行度小;不同类型的任务(查询、写库、发消息)混在同一个池里,互相抢线程。 - 对策:**按业务域拆分独立线程池**(下游查询一个池、写库一个池、发消息一个池),每个池用 `ThreadPoolExecutor` 明确核心/最大线程数、有界队列、拒绝策略,并给线程命名以便排查。 补充两个常被忽视的点: - **`join()` 和 `get()` 的异常包装不同**:`join()` 抛非受检的 `CompletionException`,`get()` 抛受检的 `InterruptedException`/`ExecutionException`。在只做编排不关心受检异常时用 `join()` 更顺手。 - **不要在回调里长时间阻塞**:无论是 `thenApply`(可能占用完成上一阶段的线程)还是 `thenApplyAsync`(占用池线程),阻塞都会降低吞吐。阻塞操作应该有独立的池和超时。 ### Q:一个完整的"多服务并行查询再聚合"示例? A:结论先行——**用独立业务线程池并行发起多个下游调用,每个调用设置超时与降级,再用 `allOf` 聚合、`thenApply` 组装结果**;这样任一服务慢或挂,都不会拖死整个接口。 ```java import java.util.*; import java.util.concurrent.*; public class OrderDetailAggregator { // 业务专用线程池:只服务下游查询,与其它异步任务隔离 private static final ThreadPoolExecutor BIZ_POOL = new ThreadPoolExecutor( 8, 16, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(500), r -> { Thread t = new Thread(r, "agg-biz-" + System.nanoTime()); t.setDaemon(true); return t; }, new ThreadPoolExecutor.CallerRunsPolicy()); // 对外的聚合入口 public OrderDetailVO queryOrderDetail(String userId, String orderId) { // 1) 三个下游并行发起,每个都带超时 + 降级,保证异常不扩散 CompletableFuture<UserInfo> userF = CompletableFuture .supplyAsync(() -> userClient.query(userId), BIZ_POOL) .orTimeout(800, TimeUnit.MILLISECONDS) .exceptionally(ex -> { log.warn("查询用户失败,走降级 userId={}", userId, ex); return UserInfo.empty(); }); CompletableFuture<OrderInfo> orderF = CompletableFuture .supplyAsync(() -> orderClient.query(orderId), BIZ_POOL) .orTimeout(800, TimeUnit.MILLISECONDS) .exceptionally(ex -> { log.warn("查询订单失败,走降级 orderId={}", orderId, ex); return OrderInfo.empty(); }); CompletableFuture<List<Coupon>> couponF = CompletableFuture .supplyAsync(() -> couponClient.listByUser(userId), BIZ_POOL) .orTimeout(500, TimeUnit.MILLISECONDS) .exceptionally(ex -> { log.warn("查询优惠券失败,走降级 userId={}", userId, ex); return Collections.emptyList(); }); // 2) allOf 等三个都完成;因为都已 exceptionally 兜底,这里不会因单个失败而异常 CompletableFuture<Void> all = CompletableFuture.allOf(userF, orderF, couponF); // 3) 全部完成后,join 回各结果(此时必然已完成,不会阻塞)并组装 CompletableFuture<OrderDetailVO> result = all.thenApply(v -> { OrderDetailVO vo = new OrderDetailVO(); vo.setUser(userF.join()); vo.setOrder(orderF.join()); vo.setCoupons(couponF.join()); return vo; }); // 4) 在接口出口处统一阻塞取结果,最多等所有分支自己的超时 return result.join(); } } ``` 预期行为:三个下游调用并行执行,接口总耗时接近最慢的那个分支而不是三者之和;任一分支超时或抛异常时,会被 `exceptionally` 兜成默认值,接口仍然返回 200,只是对应字段为空;`log.warn` 记录降级原因便于告警。 关键点与适用边界: - **每个分支先 `orTimeout` 再 `exceptionally`**:超时会被转成异常,再由 `exceptionally` 兜住,形成"超时即降级"。 - **`exceptionally` 一定要写在 `allOf` 之前**:否则一个分支失败会让 `allOf` 异常完成,`thenApply` 被跳过。 - **`all.thenApply` 里 `join()` 是安全的**:因为 `all` 完成意味着三个分支都已完成,`join()` 立即返回。若你把 `join()` 写在 `allOf` 之前,就会阻塞等待,白白占住线程。 - **最外层才 `join()`**:整个链路只在 `queryOrderDetail` 返回前阻塞一次,中间的编排全部是非阻塞的。 - **不适用**:如果各下游之间存在严格顺序依赖(B 要用 A 的结果),应改用 `thenCompose` 串起来,而不是 `allOf`;如果每个分支的失败都必须让整个接口失败,则去掉 `exceptionally`,改在出口捕获 `CompletionException` 统一返回错误。 > 备注:示例中的 `userClient`/`orderClient`/`couponClient`/`log` 为占位符,请替换为真实客户端与日志组件;线程池参数(核心/最大线程数、队列容量、超时时间)需结合你的下游 SLA 与压测结果确定,不要照搬。 ### Q:关于 CompletableFuture,最容易搞错的三个认知是什么? A:结论先行——**"异步就等于并行""thenXxx 一定会执行""exceptionally 能接住所有异常"都是错的。** 1. **"提交了就并行"**:`supplyAsync` 只是把任务交给线程池,是否并行取决于池里有没有空闲线程。默认 `commonPool` 并行度可能只有 3,提交 10 个任务照样排队执行。 2. **"thenXxx 一定会执行"**:一旦上游异常,后续的 `thenApply`/`thenAccept`/`thenRun` 会被**整条跳过**,直到遇到 `exceptionally`/`handle`。所以"收尾动作"不要盲目挂在 `thenRun` 上——它未必会跑。 3. **"exceptionally 能接住一切"**:它只能接住**上游传递下来的异常**;如果它内部再抛异常,就会以新异常继续向下传递,等于没兜住。另外,`CompletableFuture` 被 `cancel()` 后,`exceptionally` 通常不会执行(取消以 `CancellationException` 呈现),这类"取消"分支需要在 `handle` 里判断,或在外层检查 `isCancelled()`。 这三条都是从"结构"而非"语法"出发的理解,能帮你在写编排时少踩坑。 ### Q:什么场景不该用 CompletableFuture? A:结论先行——**当异步带来的收益低于"代码复杂度 + 排障成本"时,不要用**。它适合"多个独立 IO 等待、需要并行或编排"的场景,不适合简单同步调用与强事务一致性链路。 - **本来就是同线程内完成的 CPU 计算**:用 `CompletableFuture` 包一层,只是多一次线程提交/切换,反而更慢;并行计算/分治应优先考虑 Fork/Join 或并行流。 - **调用之间有严格的事务边界**:异步线程拿不到外层事务的 `Connection`/事务上下文,跨线程的数据库写不在同一个事务里,容易产生数据不一致。这类链路要保持同步。 - **对可观测性要求高、团队缺少异步排障经验**:异步栈排查(谁提交的、跑在哪个池、异常在哪被吞、上下文在哪丢)远比同步栈困难。上异步之前,先把线程命名、链路追踪、异常终点这些规范建好。 - **框架已有更合适的方案**:流式、背压、复杂事件组合用响应式(Reactor/RxJava)更完备;`CompletableFuture` 的定位是"轻量、无第三方依赖的异步编排",别硬扛它驾驭不了的场景。 **一句话**:CompletableFuture 的收益来自"把多个独立的 IO 等待重叠起来"。只有当"等待"确实是瓶颈时才划算,否则就是给自己加复杂度。 ## 小结 把编排按"目标 → 方法"记成一张表,写异步时先想清楚要做什么,再选方法: - **创建**:要结果 `supplyAsync`,不要结果 `runAsync`,已确定值 `completedFuture`,**always 显式传线程池**。 - **串行**:转换 `thenApply`,消费 `thenAccept`,只做后续动作 `thenRun`,下一步也是异步 `thenCompose`。 - **并行聚合**:合并两值 `thenCombine`,合并消费 `thenAcceptBoth`,等全部 `allOf`,等任一 `anyOf`。 - **异常**:兜底恢复 `exceptionally`,统一出口 `handle`,旁路记录 `whenComplete`(不吞异常)。 - **超时**:异常完成 `orTimeout`,默认值完成 `completeOnTimeout`(JDK 9+)。 - **阻塞取结果**:优先 `join()`,只在最外层阻塞一次。 三条生产军规:**异常必须有终点、阻塞只放最外层、线程池必须隔离并显式指定。** ## 思考题 1. 为什么 `thenApply` 会得到 `CF<CF<T>>` 而 `thenCompose` 得到 `CF<T>`?请写出一个用 `thenApply` 导致嵌套、再用 `thenCompose` 修正的对比代码。 2. 在 `main` 线程里对一个**已经完成**的 `CompletableFuture` 调 `thenApply`,回调跑在哪个线程?如果把同样的调用换成 `thenApplyAsync`(不传 Executor),又跑在哪个线程?这解释了什么生产隐患? 3. 用 `allOf` 聚合 3 个任务,其中第 2 个任务抛了异常:`allOf` 返回的 future 会处于什么状态?后面的 `thenApply` 会执行吗?如果希望"单个失败不影响整体",代码应该怎么改? 4. `whenComplete` 和 `exceptionally` 都像是"异常处理",为什么说 `whenComplete` 不能用来兜底?请从返回类型和异常传播两个角度说明。 5. 你有一段代码在 `thenApplyAsync` 里打印 `ThreadLocal` 中的 traceId,结果一直是 null。请给出两种可靠的修复方案,并说明为什么 `InheritableThreadLocal` 在线程池场景下不可靠。 6. 项目还在 JDK 8,但需要给异步调用加超时。请描述一种用 `ScheduledExecutorService` 实现 `orTimeout` 等价效果的思路,并指出它与 JDK 9 `orTimeout` 在"是否终止底层任务"上的共同局限。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入