一个接口要并行调用三个下游,再合并结果。代码用 CompletableFuture 串起来,最后调 join() 等全部完成。测试环境一切正常,线上偶尔整个请求卡住,线程栈停在 join 上,下游其实早就返回了。
排查后发现,其中一个下游的回调里又提交了任务到同一个公共线程池,而公共池的线程已经全被阻塞的 join 占满。新任务排不进去,回调完不成,外层 join 就永远等下去。异步代码最容易出的问题不是「没异步」,而是「用异步的写法做了阻塞的事」。
这篇讲两套解决并发的工具:CompletableFuture 和虚拟线程。前者把「等待」变成回调组合,后者把「一个任务一个线程」的成本降下来。最后会实测 JDK 21 的预览特性结构化并发,并明确标出哪些结论来自本机运行、哪些只是机制解释。
CompletableFuture:组合,而不是嵌套回调
CompletableFuture 表示一个「未来会有结果」的计算。它既可以手动完成,也可以由一个异步任务完成;可以在上面挂回调、转换结果、合并多个结果、处理异常。它的价值在于把回调写成链,而不是一层套一层的匿名类。
CompletableFuture<String> f = CompletableFuture.supplyAsync(() -> {
sleep(300);
return "ok";
});
CompletableFuture<Integer> len = f.thenApply(String::length);
System.out.println(len.join());
javac -encoding UTF-8 JavaAsyncDemo.java
java -Dstdout.encoding=UTF-8 -cp . JavaAsyncDemo
组合结果 : 2
supplyAsync 在默认执行器里跑任务,thenApply 在结果出来后做转换,最后 join 拿到值。整条链没有阻塞,直到你主动调用 join 或 get。常用的组合方法还有 thenCompose(把返回 Future 的步骤压平)、thenCombine(合并两个独立结果)、allOf(等全部完成)、anyOf(等任意一个完成)。
不传执行器时,supplyAsync 用的是 ForkJoinPool.commonPool()。这个池和上一篇 parallelStream 用的是同一个,默认并行度是 CPU 核数减一。本机 CPU 是 12 核,公共池并行度是 11。它适合短小的 CPU 任务,不适合长时间阻塞:池子只有这么大,几个阻塞任务就能把它占满。
两个容易混淆的方法要分清:thenApply 的转换函数返回普通值,适合「拿到结果再加工」;thenCompose 的转换函数返回另一个 CompletableFuture,适合「下一步还是异步」的场景。用错不会报错,只会得到一个嵌套的 CompletableFuture<CompletableFuture<T>>,然后发现自己要多调一次 join。thenCombine 则用于两个互不依赖的任务,等两边都完成再合并。
回调在哪个线程执行,取决于完成方式和是否用了 Async 后缀。thenApply 可能在完成上一个阶段的线程里直接执行,也可能在调用 complete 的线程里执行;thenApplyAsync 会重新提交到执行器。这个差别会影响 ThreadLocal、事务上下文和 MDC 日志,不能假设回调一定在「你的线程」里。
异常:join 和 get 包的不一样
CompletableFuture 的异常不会自动冒出来,必须有人去拿结果才会暴露。拿结果有两条路:join 抛 CompletionException(非受检),get 抛 ExecutionException(受检),两者都把原始异常放在 getCause() 里。下面这段代码故意制造除零:
CompletableFuture<Integer> bad = CompletableFuture.supplyAsync(() -> 1 / 0);
try {
bad.join();
} catch (CompletionException e) {
System.out.println(e.getClass().getSimpleName()
+ " / 原因 : " + e.getCause().getClass().getSimpleName());
}
System.out.println(bad.handle((v, e) -> e == null ? v : -1).join());
join 抛出 : CompletionException / 原因 : ArithmeticException
handle 恢复为 : -1
注意 CompletionException 只是包装,真正的错误是 ArithmeticException。日志里只打外层异常,会丢掉最有用的信息;要打 getCause(),或者用支持异常链的日志框架。这个问题在多层 Future 组合时更明显,可能外面包了两三层。
处理异常有三个常用方法:exceptionally 只处理异常并给一个兜底值;handle 同时拿到结果和异常,返回一个新结果;whenComplete 不改结果,只做副作用,适合记日志和清理。三者都不会「让异常消失」,除非你显式返回一个正常值。
用 get 的人还要处理 InterruptedException 和 TimeoutException,异常类型更多,但都是受检异常,编译器会逼着你写 catch。用 join 更省事,却容易漏掉异常处理。团队里统一一种风格,比两种混用更容易维护。
join、get 或挂异常回调,它的异常会被静默吞掉。任务看起来提交了,实际上失败了,日志里什么都没有。每个异步入口至少挂一个 whenComplete 记录失败,否则线上会丢失整类错误。超时也有专门的 API。orTimeout 在指定时间后把 Future 完成为 TimeoutException,completeOnTimeout 则给一个默认值。两者都只是「让等待方不再等」,不会中断底层真正在跑的任务。底层任务如果永远不结束,线程和资源仍然被占着,所以超时之外还要保证任务本身可取消。
本机实测一个耗时 1 秒的任务,用 get(2, TimeUnit.SECONDS) 获取,耗时约 1012 毫秒:
get 结果 : slow / 耗时 ms : 1012
这个数字说明 get 本身是阻塞的,超时只是上限,不是固定等待时间。想要「到点就返回」,用 orTimeout 或 completeOnTimeout,不要靠 get 的超时参数控制响应时间。
虚拟线程:让阻塞重新变得便宜
平台线程和操作系统线程一一对应,创建成本高、栈空间固定,数量上不去。虚拟线程是 JVM 自己调度的轻量线程,遇到阻塞操作时会「卸载」:把载体线程让出来,等阻塞结束再重新挂上去。所以它可以创建很多个,而不用为每个都准备一套操作系统资源。
创建方式有两种:Thread.ofVirtual().start(...) 直接启动一个,或者 Executors.newVirtualThreadPerTaskExecutor() 得到一个「每个任务一个虚拟线程」的执行器。后者适合替代「一个请求一个线程」的模型,任务提交进去就返回,不用自己管线程。
long t0 = System.nanoTime();
try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 10000; i++) {
exec.submit(() -> { Thread.sleep(1000); return 1; });
}
}
System.out.println((System.nanoTime() - t0) / 1_000_000);
10000 个虚拟线程耗时 ms : 1112
一万个虚拟线程,每个都睡 1 秒,整体约 1112 毫秒完成。关键不是「一万个线程同时跑」,而是它们在睡眠时都不占载体线程,调度器只需要少量载体就能推进全部任务。换成平台线程,一万个线程的栈和调度开销会非常可观,多数环境根本撑不住。
本机还验证了线程身份:Thread.ofVirtual().start(...) 启动的线程,Thread.currentThread().isVirtual() 返回 true。这不是靠命名猜的,是 API 直接给出的结论。虚拟线程的默认名字也能看出来,但不要依赖名字判断类型。
「卸载」发生在哪些操作上,决定了虚拟线程的实际收益。调用 Thread.sleep、等待网络 IO、等待队列、等待 ReentrantLock 时,虚拟线程通常会把载体让出来;而纯计算、持有 synchronized 监视器时阻塞、或者调用本地方法,往往不会卸载。写代码时判断不了,就用前面说的压测和 JFR 观察,别凭感觉。
载体线程的数量默认接近 CPU 核数,可以用 jdk.virtualThreadScheduler.parallelism 调整。本机是 12 核,默认载体数也在这个量级。这个参数不是越大越好:载体是真正的平台线程,开得太多,调度和内存开销都会上来。虚拟线程的卸载依赖操作系统对阻塞操作的感知,相关底层机制见 操作系统:I/O 模型。
虚拟线程的边界:钉住、池化与 CPU 密集
虚拟线程不是「所有场景都更快」。它解决的是「大量阻塞任务」的成本问题。计算密集的任务,虚拟线程没有额外优势,因为真正干活的是载体线程,数量还是受 CPU 核数限制。
更隐蔽的是「钉住」(pinning)。虚拟线程在 synchronized 块里执行阻塞操作时,不能卸载,会把载体线程一起占住。载体线程数量有限,几个这样的虚拟线程就能把调度器堵死。本机把调度器并行度设成 1,让四个虚拟线程各睡 500 毫秒,对比了两种情况:
java -Djdk.virtualThreadScheduler.parallelism=1 PinningDemo
普通 sleep 耗时 ms : 527
synchronized 内 sleep 耗时 ms : 2052
普通睡眠时四个任务几乎同时完成,约 527 毫秒;把睡眠放进 synchronized 块后,四个任务串行占住唯一的载体,总耗时约 2052 毫秒,接近四倍。这不是理论,是本机 JDK 21 跑出来的结果。结论很直接:虚拟线程里尽量用 ReentrantLock 替代 synchronized,尤其是临界区里还有 IO 或等待的时候。
第二,不要池化虚拟线程。虚拟线程本来就便宜,用完即弃;把它放进固定大小的池,等于把轻量线程又变回有限资源,阻塞时还会互相排队。正确做法是每个任务创建一个,或者用 newVirtualThreadPerTaskExecutor。真正需要限制并发的地方,用信号量控制任务数量,而不是限制线程数量。
第三,虚拟线程数量也不是无限的。每个虚拟线程仍然是一个 Java 对象,任务对象、栈片段、待处理的数据都要占内存。无限制地提交任务,照样会 OOM。用 Semaphore 或带界的队列控制进入量,是使用虚拟线程时的常规配套。
这三层解释了虚拟线程的两种典型故障:任务突然变慢,可能是载体被钉住;任务排队很久,可能是并发量超过了预期,或者临界区里有阻塞操作。
结构化并发:让子任务有明确的父子关系
CompletableFuture 的组合是「谁拿到引用谁负责」,任务散落之后很难确保全部结束。结构化并发换了一种写法:在一个作用域里派生子任务,作用域结束时必须全部完成或被取消,父任务不会先走。
JDK 21 里的 StructuredTaskScope 是预览 API,编译和运行都要加 --enable-preview。本机实测的命令和输出如下:
javac --release 21 --enable-preview -encoding UTF-8 StructuredDemo.java
java --enable-preview -cp . StructuredDemo
两个子任务结果 : user / 42
scope 传播异常 : ExecutionException / java.lang.IllegalStateException: 子任务失败
第一个作用域派生了两个子任务,一个返回字符串,一个返回整数,join 之后一起拿结果。第二个作用域里一个子任务抛异常,throwIfFailed 把异常传播出来,类型是 ExecutionException,原始异常在 cause 里。
ShutdownOnFailure 的语义是「一个失败就取消其他」:只要有一个子任务抛异常,其余子任务会被取消,join 提前返回。还有 ShutdownOnSuccess,任意一个成功就取消其余,适合「多个镜像取最快」的场景。作用域用 try-with-resources 关闭,保证不会漏掉线程。
预览 API 意味着它还不是正式标准,签名和语义可能在未来版本调整,生产环境使用要谨慎。学习阶段可以用它理解「结构化」的思想:子任务的生命周期被父作用域包住,不会出现「请求结束了,后台还在跑」的失控情况。
和 CompletableFuture 相比,结构化并发的优势在「收口」。Future 链一旦被传递出去,创建者就无法保证它一定被等待;作用域则强制在离开代码块之前处理所有子任务。代价是灵活性下降:你不能把一个子任务「发射后不管」,也不能跨作用域随意组合。需要长期运行的后台任务,本来就不适合放进请求级的作用域。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
join 永远不返回 | 前置阶段没有完成,或公共池被阻塞任务占满 | 看线程栈是不是停在 join;检查回调里有没有阻塞操作 |
| 异步任务失败了,日志里什么都没有 | 没有任何阶段调用 join、get 或异常回调 | 给每条链挂 whenComplete,记录异常和耗时 |
捕获到 CompletionException,看不到根因 | 异常被包装,原始异常在 getCause() | 打印完整异常链;不要只打 getMessage() |
| 回调里 ThreadLocal 或事务上下文丢了 | 回调在别的线程执行,或者是 Async 版本切换了线程 | 确认用的是同步回调还是异步回调;显式传递上下文 |
| 接口整体变慢,CPU 却不高 | 公共池被阻塞任务占满,任务在排队 | 看公共池并行度和活跃线程;给阻塞任务单独的池 |
| 虚拟线程没有提升吞吐 | 任务是 CPU 密集型,或者临界区里有阻塞 | 看任务类型;排查 synchronized 里的 IO 和等待 |
| 虚拟线程任务串行执行 | 在 synchronized 里阻塞,钉住了载体 | 把 synchronized 换成 ReentrantLock;缩短临界区 |
| 虚拟线程越来越多,内存上涨 | 没有限制提交量,任务对象和栈片段堆积 | 加 Semaphore 或带界队列;限制并发任务数 |
| 结构化并发代码编译失败 | 没有开启预览特性 | 编译和运行都加 --enable-preview,并确认 JDK 版本 |
排查异步问题,先问三个问题:这个任务由谁负责等待、异常最后由谁处理、回调在哪个线程执行。三个问题都有明确答案,代码才算是可控的。答不上来,说明还有任务在「放飞」。
边界与代价
这两套工具都很强,但都有明确的适用边界:
CompletableFuture的链难调试:堆栈里全是合成方法和回调,异常被多层包装。链越长,定位越难。复杂流程用同步代码加线程池,往往比一条长链更好维护。- 公共池是共享资源:默认执行器被所有异步任务共用,一个阻塞任务能拖累全部。阻塞操作要用独立线程池,不要往公共池里扔。
- 超时不等于取消:
orTimeout只是让等待方返回,底层任务可能还在跑。需要真正取消,任务必须响应中断,或者自己检查取消标记。 - 虚拟线程不加速计算:CPU 密集任务用它不会更快,反而多一层调度。它只降低「阻塞等待」的成本。
- 钉住无法完全避免:第三方库里的
synchronized不受你控制。上线前用压测和 JFR 观察载体线程的使用情况,别假设「我的代码没写 synchronized 就不会钉住」。 - 结构化并发仍是预览:需要
--enable-preview,API 可能变化。学习和内部工具可以用,核心生产系统要评估版本风险。 - 上下文传递要显式:线程切换后 ThreadLocal 不会自动跟过去,虚拟线程数量大时滥用 ThreadLocal 还会放大内存。请求 id、用户信息这类上下文,要么随参数传,要么用专门的上下文传播机制。
还有一个容易忽略的成本:异步让调用链变长,出错时的上下文(请求 id、用户 id、耗时)很容易丢。无论用 Future 还是虚拟线程,都要显式传递这些上下文,或者在入口处统一绑定。并发工具解决的是调度问题,不是可观测性问题。
当天能自己验证的练习
- 用
supplyAsync加thenApply组合一条链,打印最终结果;再把thenApply换成thenApplyAsync,在回调里打印线程名,观察执行线程的变化。 - 制造一个除零的异步任务,分别用
join和get获取,记录两种异常类型和getCause();再用handle给一个兜底值。 - 用
newVirtualThreadPerTaskExecutor提交一万个睡 1 秒的任务,记录总耗时,并打印其中一个线程的isVirtual()。 - 把调度器并行度设成 1,跑四个虚拟线程的睡眠测试,分别在普通睡眠和
synchronized内睡眠,对比总耗时。 - 用
StructuredTaskScope.ShutdownOnFailure派生两个子任务,一个成功一个抛异常,编译运行时加--enable-preview,记录throwIfFailed抛出的异常类型。
小结
三句话收一下:CompletableFuture 的异常藏在 CompletionException 或 ExecutionException 里,必须有人 join、get 或挂回调,否则失败会被静默吞掉;虚拟线程降低的是阻塞成本,一万个睡一秒的任务约 1.1 秒完成,但它不加速 CPU 计算;synchronized 里的阻塞会钉住载体,本机在并行度为 1 时把 0.5 秒的并发拖成了 2 秒。
到这里,Java 组的八篇就结束了。从类型和语法,到泛型、集合、文件、网络、进程、线程,再到异步,覆盖的是一条「从内存里的值到系统间的协作」的路径。下一步可以挑一个真实项目,把其中的一处同步调用改成虚拟线程,或者把一条回调链改成 CompletableFuture,用今天的排查表验证自己的实现。