Appearance
2.4-12 结构化并发与 ScopedValue
所属:02 Java 运行时 / 2.4 并发 分级:B(按 A 类模板展开) 状态:◐ 初稿 关联:2.4-6、2.4-8、2.4-11、2.4-13、6.7-4
题型:原理 / 对比 / 场景
一句话结论:结构化并发用词法作用域把子任务的生命周期绑在父任务块内,父任务不结束子任务就不能逃逸,失败会取消兄弟任务、超时会整体收口,解决的是
ExecutorService/CompletableFuture的孤儿任务、异常丢失和取消不传播;ScopedValue 是不可变、随作用域自动恢复的上下文传递机制,能被子任务继承、没有 ThreadLocal 的泄漏和虚拟线程内存放大问题。两者互补:虚拟线程负责“轻”,结构化并发负责“生命周期”,ScopedValue 负责“上下文”。截至 JDK 25,ScopedValue已转正(JEP 506),结构化并发仍是 preview(JEP 505),API 随版本变,面试要按目标 JDK 说。分层要点:
- 概念先行:结构化并发不是新线程类型,而是任务生命周期的一种纪律:在同一个代码块里 fork 出子任务,离开块之前必须 join/收口;父任务的作用域就是子任务的生命周期边界。它和虚拟线程是正交的——虚拟线程让“一个任务一个线程”变便宜,结构化并发让“一堆任务”有明确的父子树和取消语义。
- 它解决什么:传统
ExecutorService提交后返回Future,父任务可以先返回,子任务继续跑(孤儿任务);CompletableFuture的异常要靠链尾观察,取消不向上游传播;手写join循环容易在第一个异常时忘记取消其他任务。结构化并发把这些收进一个try-with-resources:失败取消兄弟、超时统一收口、异常不会被静默吞掉、线程 dump 能看到任务树(2.4-13)。 - API 形态与版本:JDK 19/20 是 incubator(JEP 428/437),JDK 21 起 preview(JEP 453),22/23/24/25 持续 preview(JEP 462/480/499/505)。早期写法是
new StructuredTaskScope.ShutdownOnFailure()+fork+join+throwIfFailed;JDK 25 的 JEP 505 改成StructuredTaskScope.open(Joiner)+scope.join()返回结果,ShutdownOnFailure/ShutdownOnSuccess由Joiner策略取代。API 还在变,代码示例必须对照目标 JDK 的 Javadoc;preview 需要--enable-preview。 - 任务树与取消传播:每个
fork的子任务默认跑在虚拟线程上(早期预览版;后续是否可定制线程工厂按版本确认);父任务join等待全部子任务;任一子任务失败时,ShutdownOnFailure/Joiner策略会shutdown其余子任务,底层通过中断实现。子任务必须在阻塞点响应中断,纯 CPU 循环要自己检查Thread.interrupted();joinUntil(Instant)到达截止时间会关闭 scope 并取消未完成的子任务。 - 结果与异常读取:
Subtask.get()会阻塞到该子任务完成(可被中断);resultNow()只在成功后可调用,否则抛IllegalStateException;exceptionNow()只在失败后可调用;state()返回SUCCESS/FAILED/UNAVAILABLE。throwIfFailed()(旧 API)或Joiner策略负责把失败抛出来;拿到结果后不要越过 scope 边界使用,scope 关闭后结果不再受保护。 - ScopedValue 的语义:
ScopedValue.newInstance()创建 key,值通过ScopedValue.where(KEY, value).run(...)或.call(...)绑定到一个词法作用域;作用域内KEY.get()读取,离开后自动恢复(未绑定时get()抛NoSuchElementException,可用isBound()/orElse()/orElseThrow())。绑定不可变、值不能为 null;嵌套where对同一 key 重绑定会遮蔽外层,退出内层自动恢复外层。 - 继承与边界:ScopedValue 绑定会被结构化并发的子任务继承;普通
new Thread和线程池任务不会自动继承。这一点决定了它的适用面:请求级上下文、租户/用户、traceId、事务/安全上下文在结构化 fan-out 里天然可用;但@Async、CompletableFuture、Reactive 线程切换、日志框架的 MDC 都不认它,需要适配。可变状态仍然要用 ThreadLocal 或其他机制,ScopedValue 假设值是 effectively immutable。 - 选型与取舍:请求级并发分解(fan-out 调用多个 RPC、聚合结果)优先结构化并发;需要长期运行、队列、拒绝策略的后台任务仍用
ExecutorService;流式/背压用 Reactor;简单的一两个异步调用用CompletableFuture或直接虚拟线程同步调用。ScopedValue 适合不可变上下文,ThreadLocal 适合可变线程状态和需要框架兼容的场景。结构化并发的代价是 API 仍 preview、scope 必须短命、依赖子任务合作式响应中断。
图/流程:
text
结构化任务树与生命周期:
请求线程 / 父任务
┌──────────────────────────────────────────────┐
│ try (var scope = StructuredTaskScope.open()) │
│ fork(user) ──► 子任务1(虚拟线程) │
│ fork(order) ──► 子任务2 │
│ fork(coupon) ──► 子任务3 │
│ scope.join() ← 等待全部完成/失败/超时 │
│ ... 使用结果 ... │
└──────────────────────────────────────────────┘
离开块 ⇒ scope 关闭 ⇒ 未完成子任务被取消,不可能逃逸text
失败与取消传播:
子任务2 抛异常
→ Joiner/ShutdownOnFailure 记录异常
→ scope.shutdown() ← 取消子任务1、3(中断)
→ scope.join() 返回 / 抛异常
→ 父任务统一处理,不会留下孤儿任务
超时:
joinUntil(deadline)
→ 到点仍未完成 ⇒ 关闭 scope,取消未完成子任务text
ScopedValue 的作用域与恢复:
未绑定:KEY.isBound() == false, KEY.get() 抛 NoSuchElementException
where(KEY, "a").run(() -> {
KEY.get() == "a"
where(KEY, "b").run(() -> {
KEY.get() == "b" // 内层遮蔽
});
KEY.get() == "a" // 自动恢复
});
// 离开后再次未绑定text
继承规则:
ScopedValue.where(KEY, v).run(() -> {
try (var scope = StructuredTaskScope.open()) {
scope.fork(() -> KEY.get()); // ✓ 继承 v
}
new Thread(() -> KEY.isBound()); // ✗ 不继承
executor.submit(() -> KEY.isBound());// ✗ 不继承
});java
// JDK 21–24 preview 写法(示意,签名随版本变化)
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
Subtask<User> user = scope.fork(() -> userClient.get(id));
Subtask<Order> order = scope.fork(() -> orderClient.get(id));
scope.join();
scope.throwIfFailed();
return new Resp(user.resultNow(), order.resultNow());
}
// JDK 25 (JEP 505) 形态(示意,按目标 JDK 核对)
try (var scope = StructuredTaskScope.open(
StructuredTaskScope.Joiner.<Object>allSuccessfulOrThrow())) {
scope.fork(() -> userClient.get(id));
scope.fork(() -> orderClient.get(id));
return scope.join();
}
// ScopedValue
static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();
ScopedValue.where(CURRENT_USER, user).run(() -> handle());版本/源码锚点:
- 结构化并发:JEP 428(JDK 19 incubator)→ JEP 437(JDK 20 second incubator)→ JEP 453(JDK 21 preview)→ JEP 462(JDK 22 2nd preview)→ JEP 480(JDK 23 3rd preview)→ JEP 499(JDK 24 4th preview)→ JEP 505(JDK 25 5th preview)。截至 JDK 25 仍未转正,后续版本状态按你的 JDK 确认。
- ScopedValue:JEP 429(JDK 20 incubator)→ JEP 446(JDK 21 preview)→ JEP 464(JDK 22 2nd preview)→ JEP 487(JDK 23 3rd preview)→ JEP 506(JDK 25 正式)。
- 关键类/方法:
java.util.concurrent.StructuredTaskScope、StructuredTaskScope.Subtask、StructuredTaskScope.Joiner、ShutdownOnFailure/ShutdownOnSuccess(旧 API);java.lang.ScopedValue、ScopedValue.where(...).run/call、Carrier、get/isBound/orElse/orElseThrow。 - 线程与观测:子任务默认虚拟线程(JDK 21 preview 起);线程 dump 可看到虚拟线程,结构化任务树的可观测性按 JEP 版本确认;JFR 对虚拟线程有
jdk.VirtualThread*事件。 - 生态:
@Async、CompletableFuture、Reactor 的线程切换不会自动继承 ScopedValue;MDC 需要显式桥接。
ScopedValue vs ThreadLocal:
| 维度 | ThreadLocal | ScopedValue |
|---|---|---|
| 可变性 | 可变,set/get/remove | 不可变,作用域内只读 |
| 生命周期 | 跟随线程,需手动 remove | 跟随词法作用域,退出自动恢复 |
| 存储 | 每线程一个 ThreadLocalMap | 共享不可变绑定,线程读同一份 |
| 泄漏风险 | key 弱引用、value 强引用,线程池易泄漏 | 作用域结束即释放,无泄漏 |
| 继承 | InheritableThreadLocal 仅创建时复制 | 结构化并发子任务自动继承 |
| 虚拟线程 | 每个虚拟线程一份 map,量大放大内存 | 绑定共享,适合海量虚拟线程 |
| 性能 | map 查找,通常够快 | 读取轻量,绑定建立有成本 |
| 适用 | 可变线程状态、框架兼容 | 请求上下文、不可变配置、traceId |
| 工具支持 | MDC 等广泛支持 | 日志/框架需适配 |
- 结构化并发 API 速查:
| API | 作用 | 注意 |
|---|---|---|
open() / new StructuredTaskScope... | 创建 scope | 旧/新 API 形态不同 |
fork(Callable) | 派生 Subtask | 默认虚拟线程,立即开始执行 |
join() | 等待全部子任务 | 可被中断 |
joinUntil(Instant) | 带截止时间等待 | 超时关闭 scope 并取消 |
shutdown() | 取消未完成子任务 | 通过中断 |
close() | 关闭 scope | try-with-resources 自动调用 |
Subtask.get() | 阻塞取结果 | 可被中断 |
Subtask.resultNow() | 立即取成功结果 | 未成功抛 IllegalStateException |
Subtask.exceptionNow() | 立即取异常 | 未失败抛 IllegalStateException |
Subtask.state() | 状态 | SUCCESS/FAILED/UNAVAILABLE |
throwIfFailed() | 失败则抛 | 旧 API(ShutdownOnFailure) |
Joiner 策略 | 结果聚合/失败处理 | JDK 25 新 API |
- 结构化并发 vs 其他方案:
| 维度 | ExecutorService | CompletableFuture | StructuredTaskScope | Reactor |
|---|---|---|---|---|
| 生命周期 | 手动,孤儿任务可能 | 链式,父可先返回 | 词法作用域,父等子 | 订阅生命周期 |
| 失败传播 | 手动检查 Future | 沿链,易被吞 | 自动取消兄弟并抛出 | onError 操作符 |
| 取消 | Future.cancel 有限 | 不向上游传播 | shutdown + 中断传播 | cancel 向下传播 |
| 超时 | 手动 | orTimeout 不中断任务 | joinUntil + 取消 | timeout 操作符 |
| 上下文 | 手动/ThreadLocal | 不传播 | ScopedValue 继承 | Context |
| 适用 | 长期池/队列/后台任务 | 简单扇出 | 请求级并发分解 | 流式/背压 |
- 常见坑清单:
| 现象 | 根因 | 处理 |
|---|---|---|
| 请求返回后子任务还在跑 | 用了 Executor/CF 而非结构化 scope | 请求级 fan-out 改用 scope,父等子 |
| 一个下游失败,其他调用还在跑 | 未取消兄弟任务 | ShutdownOnFailure/Joiner 自动取消 |
| 子任务异常没人知道 | 只 join 未 throwIfFailed/未观察 | 用策略收口,或逐个 get |
| 超时后线程泄漏 | 只设 joinUntil,子任务不响应中断 | 下游客户端超时 + 代码检查中断 |
resultNow() 抛 IllegalStateException | 子任务未成功就取结果 | 先 state()/get() |
| scope 外使用结果 | scope 已关闭,结果不再受保护 | 在 scope 内完成结果组装 |
| ScopedValue 在异步线程读不到 | 线程池/CF 不继承绑定 | 显式传参或只在结构化子任务用 |
| MDC 里没有 traceId | 日志框架不认 ScopedValue | 桥接/装饰器显式注入 |
| ScopedValue 值被并发修改 | 放了可变对象 | 用不可变对象,或改用 ThreadLocal |
| 升级 JDK 编译失败 | preview API 签名变化 | 锁定 JDK 版本,按 Javadoc 迁移 |
| 子任务 CPU 死循环不退出 | 中断只在阻塞点生效 | 循环里检查 Thread.interrupted() |
| 把长任务放进 scope | scope 应短命 | 长期任务用 Executor/调度器 |
深挖点(面试官常追的 6 个):
- 结构化并发到底解决什么问题:它把“任务树”变成语言结构:子任务只能在父作用域内存在,父任务离开块前必须收口。对比
ExecutorService,不会出现父请求已返回、子任务还在写库的孤儿;对比CompletableFuture,失败和取消有明确的传播路径,不依赖调用方记得join和观察异常。核心收益是生命周期、失败传播、取消、可观测性四件事一起收敛。 - 取消是怎么实现的:
shutdown()对未完成子任务调用中断,虚拟线程在sleep/park/IO/queue等阻塞点抛出InterruptedException;纯 CPU 任务必须自己轮询中断标志。close()会等待收口(或按版本语义关闭),所以 scope 应包在try-with-resources里;不要在 scope 外持有Subtask引用做延迟使用。 - API 为什么一直在变:结构化并发从 incubator 到多次 preview,
ShutdownOnFailure/ShutdownOnSuccess两个子类在 JEP 505 被Joiner策略取代,open()成为入口,join()直接返回聚合结果。这反映了“策略可组合”的设计方向。面试时不要背死某一种签名,要说清版本和设计意图;preview 需要--enable-preview,生产慎用。 - ScopedValue 怎么实现继承:绑定不是写进每个线程的 map,而是构造一个不可变的绑定快照(
Carrier/内部 Snapshot 链),作用域内线程读取当前快照;结构化并发 fork 子任务时把当前快照传给子任务,所以子任务能读到。普通线程没有这条传递路径,因此不继承。作用域退出只是恢复上一个快照,不需要清理,也不会有 ThreadLocal 的弱 key/强 value 泄漏问题。 - ScopedValue 为什么要求不可变:绑定在整个作用域内对所有线程可见且不能改;如果值是可变对象,多个子任务并发修改就等价于共享可变状态,需要额外同步。正确用法是传不可变 DTO、字符串、枚举或只读配置;需要可变状态时仍用 ThreadLocal、局部变量或显式参数。
- 和虚拟线程、CF、Reactor 怎么组合:虚拟线程提供轻量执行单元,结构化并发提供生命周期,ScopedValue 提供上下文,三者是分层关系。
CompletableFuture的扇出没有结构化保证,取消不传播,复杂请求编排建议换 scope;Reactor 有自己的 Context 和背压,不需要 ScopedValue。JDK 21+ 的推荐形态是“虚拟线程 + 结构化并发 + ScopedValue”的同步风格,而不是把回调链越写越深。
- 结构化并发到底解决什么问题:它把“任务树”变成语言结构:子任务只能在父作用域内存在,父任务离开块前必须收口。对比
追问链:
- 什么是结构化并发? → 用词法作用域约束子任务生命周期,父任务结束前子任务必须收口。
- 它和虚拟线程什么关系? → 正交:虚拟线程是轻量执行单元,结构化并发是任务生命周期管理。
- 它解决 ExecutorService 的什么问题? → 孤儿任务、取消不传播、异常丢失、任务树不可见。
- 它解决 CompletableFuture 的什么问题? → 失败/取消传播不明确、异常易被吞、父任务可先返回。
- 核心 API 是什么? →
StructuredTaskScope+fork/join/joinUntil/shutdown/close。 - 子任务跑在什么线程上? → 早期预览版默认虚拟线程;后续版本按 Javadoc 确认。
- 父任务会等子任务吗? → 会,
join()等待全部完成或失败/超时。 - 子任务失败了会怎样? → 策略会取消其他子任务并让 scope 以失败收口。
- 取消怎么实现? →
shutdown()中断未完成子任务,依赖子任务在阻塞点响应中断。
- CPU 密集子任务能取消吗? → 只有检查
Thread.interrupted()才能及时退出。 - 超时怎么做? →
joinUntil(Instant),到点关闭 scope 并取消未完成子任务。 resultNow和get区别? → 前者不阻塞但要求已成功;后者阻塞等待。exceptionNow什么时候能调? → 子任务已失败时;否则抛IllegalStateException。state()有哪些值? →SUCCESS/FAILED/UNAVAILABLE。- scope 必须 close 吗? → 是,
try-with-resources保证收口,避免任务逃逸。 - 能在 scope 外使用结果吗? → 不建议,scope 关闭后结果不再受保护。
ShutdownOnFailure和ShutdownOnSuccess区别? → 前者任一失败即取消,后者任一成功即取消其余。- JDK 25 的 API 变了吗? → 变了,JEP 505 用
open(Joiner),join()返回聚合结果。 - 为什么 API 一直变? → 多次 preview,策略模型在演进;生产使用要锁版本。
- preview 怎么启用? → 编译和运行都加
--enable-preview。 - 结构化并发适合什么场景? → 请求级 fan-out、并行调用多个下游、需要失败/超时统一收口的场景。
- 不适合什么场景? → 长期后台任务、任务队列、fire-and-forget、需要背压的流式处理。
- 它能替代线程池吗? → 不能,scope 是短命的任务边界;线程池仍负责资源与队列。
- ScopedValue 是什么? → 不可变、作用域绑定、退出自动恢复的上下文传递机制。
- 怎么创建和绑定? →
ScopedValue.newInstance()+ScopedValue.where(key, value).run/call。 - 作用域外读取会怎样? →
get()抛NoSuchElementException,可用isBound/orElse。 - 能绑定 null 吗? → 不能,key 或 value 为 null 会抛 NPE。
- 嵌套重绑定会怎样? → 内层遮蔽外层,退出内层恢复外层。
- ScopedValue 和 ThreadLocal 区别? → 不可变 vs 可变、词法作用域 vs 线程生命周期、自动恢复 vs 手动 remove。
- ScopedValue 会被子线程继承吗? → 结构化并发子任务会;普通线程和线程池不会。
- 为什么普通线程不继承? → 绑定通过 scope fork 传递,普通线程没有这条路径。
- ScopedValue 会泄漏吗? → 不会,作用域结束即恢复,没有每线程 map。
- 值可以是可变对象吗? → 技术上可以,但语义上是共享可变状态,应传不可变对象。
- ScopedValue 能替代 ThreadLocal 吗? → 不能完全替代,可变线程状态仍需 ThreadLocal。
- MDC 能自动读 ScopedValue 吗? → 不能,日志框架需显式桥接。
- CompletableFuture 能继承 ScopedValue 吗? → 不能,线程切换不会自动传递绑定。
- @Async 能继承吗? → 不能,需显式传参或装饰器。
- 虚拟线程下 ScopedValue 有什么优势? → 绑定共享、无每线程 map,海量虚拟线程不会放大内存。
- ScopedValue 的性能如何? → 读取轻量,绑定建立有成本;不要在高频循环里反复 where。
- 结构化并发怎么观测? → 线程 dump 看虚拟线程与任务树,JFR 看虚拟线程事件,按版本确认。
- 子任务里能用 ThreadLocal 吗? → 能,但每个虚拟线程一份 map,量大时内存放大。
- 怎么迁移现有 Executor 扇出? → 把 fan-out 收敛到 scope,统一超时/失败/取消,结果在 scope 内组装。
- 迁移风险是什么? → preview API 变化、子任务不响应中断、scope 过长、上下文传递遗漏。
- 和 Reactor 怎么选? → 请求级阻塞 fan-out 用结构化并发;流式/背压/复杂组合用 Reactor。
- 面试怎么总结? → 结构化并发管生命周期(父等子、失败取消、超时收口)→ API 仍 preview → ScopedValue 管不可变上下文(自动恢复、子任务继承)→ 两者配合虚拟线程形成同步风格。
生产案例/取舍(示例,替换成你的项目):
- 详情页并行调用户、订单、优惠券,原来用三个
Future加循环get,一个失败后其他调用还在跑;改成ShutdownOnFailure,失败即取消兄弟,RT 和下游压力都下降。 - 扇出没有超时,某个下游抖动拖垮整页;加
joinUntil+ 下游客户端读超时,超时统一降级。 - 请求已经返回,异步子任务还在写库,重复扣减;改用结构化 scope,父任务等子任务收口。
- 子任务抛异常但没人调
throwIfFailed,接口返回空数据;策略统一收口并告警。 - 子任务里做 CPU 重计算,取消后仍跑很久;循环里补
Thread.interrupted()检查。 - 每个请求用 ThreadLocal 存用户上下文,虚拟线程数量上来后堆内存上涨;改用 ScopedValue 传不可变用户快照。
- 在
CompletableFuture.supplyAsync里读 ScopedValue 拿到未绑定异常;改为显式传参,或把 fan-out 收敛到结构化 scope。 - 日志 MDC 里没有 traceId;在 scope 入口把 ScopedValue 桥接到 MDC,退出时清理。
- ScopedValue 里放了可变 DTO,子任务并发修改导致数据错乱;改成不可变快照。
- 把
ScopedValue当 ThreadLocal 用,作用域内频繁重绑定;改为一次绑定 + 显式参数。 - 用结构化 scope 包住整段请求处理,包含慢 DB 写;scope 生命周期过长,取消粒度差;只把并发 fan-out 放进 scope。
- 升级 JDK 后 preview API 编译失败;锁定 JDK 版本,按目标版本 Javadoc 迁移,生产暂不用 preview。
- 取舍:结构化并发换生命周期和取消语义,代价是 preview 不稳定、scope 必须短命;ScopedValue 换无泄漏的上下文传递,代价是不可变约束和框架适配;虚拟线程换轻量执行,代价是仍需限流;两者都不能替代线程池的资源管理。
- 详情页并行调用户、订单、优惠券,原来用三个
易错点:
- 认为结构化并发是新的线程类型,实际它是任务生命周期模型。
- 认为结构化并发和虚拟线程是同一件事,实际正交、可组合。
- 认为 scope 里的子任务会自动取消,实际要 join/close 收口。
- 认为父任务可以先返回,实际结构化要求父等子。
- 认为子任务失败不会影响兄弟,实际策略会取消其他子任务。
- 认为取消能立刻停止 CPU 任务,实际只在阻塞点生效,需自己检查中断。
- 认为
joinUntil只是等待,实际到点会关闭 scope 并取消。 - 认为
resultNow()可以随便用,实际未成功会抛IllegalStateException。 - 认为
exceptionNow()总能拿到异常,实际未失败会抛异常。 - 认为 scope 关闭后结果仍有效,实际应在 scope 内完成组装。
- 认为
ShutdownOnFailure和ShutdownOnSuccess是固定 API,实际 JDK 25 被Joiner取代。 - 认为结构化并发已经正式,实际截至 JDK 25 仍是 preview。
- 认为 preview API 可以直接上生产,实际需要
--enable-preview且随版本变化。 - 认为结构化并发能替代线程池,实际它管不了队列、拒绝策略和长期任务。
- 认为结构化并发适合 fire-and-forget,实际它要求父等子。
- 认为 ScopedValue 是可变的,实际绑定只读。
- 认为 ScopedValue 能替代 ThreadLocal,实际可变状态仍需 ThreadLocal。
- 认为 ScopedValue 在作用域外返回 null,实际
get()抛NoSuchElementException。 - 认为 ScopedValue 可以绑 null,实际会抛 NPE。
- 认为嵌套绑定会冲突,实际内层遮蔽、外层恢复。
- 认为 ScopedValue 会被所有子线程继承,实际只有结构化子任务继承。
- 认为线程池任务能读到 ScopedValue,实际读不到。
- 认为
CompletableFuture能继承 ScopedValue,实际不能。 - 认为
@Async能继承 ScopedValue,实际不能。 - 认为 MDC 会自动读 ScopedValue,实际需要桥接。
- 认为 ScopedValue 值可以是可变对象且安全,实际是共享可变状态。
- 认为 ScopedValue 会像 ThreadLocal 一样泄漏,实际作用域结束即恢复。
- 认为 ScopedValue 一定比 ThreadLocal 快,实际要看读写比例和绑定次数。
- 认为虚拟线程下 ThreadLocal 没问题,实际每线程一份 map,量大时内存放大。
30 秒口述稿:
结构化并发是用词法作用域管任务生命周期:在 scope 里 fork 子任务,父任务 join/close 之前子任务不能逃逸;一个失败就取消兄弟,超时就整体收口,解决了 Executor 和 CompletableFuture 的孤儿任务、异常丢失、取消不传播。它默认跑虚拟线程,但两者是正交的。API 到 JDK 25 还是 preview,写法从 ShutdownOnFailure 演进到 open(Joiner),生产要锁版本。ScopedValue 是不可变的上下文绑定,where(key, value).run/call 进入作用域,退出自动恢复,没有 ThreadLocal 的泄漏和虚拟线程内存放大;结构化子任务会继承,普通线程池和 CompletableFuture 不会。可变状态还是用 ThreadLocal,两者不是替代关系。
- 3 分钟展开顺序:结论(生命周期 + 上下文两个工具)→ 结构化并发的任务树与父等子 → 失败取消/中断/超时 → API 形态与 JEP 版本线 → 与 Executor/CF/Reactor 对比 → ScopedValue 的 where/run/call、绑定与恢复 → 继承规则与 ThreadLocal 对比 → 虚拟线程下的内存优势 → 迁移与生产坑 → 选型收尾。