Skip to content

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 说。

  • 分层要点:

    1. 概念先行:结构化并发不是新线程类型,而是任务生命周期的一种纪律:在同一个代码块里 fork 出子任务,离开块之前必须 join/收口;父任务的作用域就是子任务的生命周期边界。它和虚拟线程是正交的——虚拟线程让“一个任务一个线程”变便宜,结构化并发让“一堆任务”有明确的父子树和取消语义。
    2. 它解决什么:传统 ExecutorService 提交后返回 Future,父任务可以先返回,子任务继续跑(孤儿任务);CompletableFuture 的异常要靠链尾观察,取消不向上游传播;手写 join 循环容易在第一个异常时忘记取消其他任务。结构化并发把这些收进一个 try-with-resources:失败取消兄弟、超时统一收口、异常不会被静默吞掉、线程 dump 能看到任务树(2.4-13)。
    3. 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。
    4. 任务树与取消传播:每个 fork 的子任务默认跑在虚拟线程上(早期预览版;后续是否可定制线程工厂按版本确认);父任务 join 等待全部子任务;任一子任务失败时,ShutdownOnFailure/Joiner 策略会 shutdown 其余子任务,底层通过中断实现。子任务必须在阻塞点响应中断,纯 CPU 循环要自己检查 Thread.interrupted();joinUntil(Instant) 到达截止时间会关闭 scope 并取消未完成的子任务。
    5. 结果与异常读取:Subtask.get() 会阻塞到该子任务完成(可被中断);resultNow() 只在成功后可调用,否则抛 IllegalStateException;exceptionNow() 只在失败后可调用;state() 返回 SUCCESS/FAILED/UNAVAILABLE。throwIfFailed()(旧 API)或 Joiner 策略负责把失败抛出来;拿到结果后不要越过 scope 边界使用,scope 关闭后结果不再受保护。
    6. ScopedValue 的语义:ScopedValue.newInstance() 创建 key,值通过 ScopedValue.where(KEY, value).run(...) 或 .call(...) 绑定到一个词法作用域;作用域内 KEY.get() 读取,离开后自动恢复(未绑定时 get() 抛 NoSuchElementException,可用 isBound()/orElse()/orElseThrow())。绑定不可变、值不能为 null;嵌套 where 对同一 key 重绑定会遮蔽外层,退出内层自动恢复外层。
    7. 继承与边界:ScopedValue 绑定会被结构化并发的子任务继承;普通 new Thread 和线程池任务不会自动继承。这一点决定了它的适用面:请求级上下文、租户/用户、traceId、事务/安全上下文在结构化 fan-out 里天然可用;但 @Async、CompletableFuture、Reactive 线程切换、日志框架的 MDC 都不认它,需要适配。可变状态仍然要用 ThreadLocal 或其他机制,ScopedValue 假设值是 effectively immutable。
    8. 选型与取舍:请求级并发分解(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:

维度ThreadLocalScopedValue
可变性可变,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()关闭 scopetry-with-resources 自动调用
Subtask.get()阻塞取结果可被中断
Subtask.resultNow()立即取成功结果未成功抛 IllegalStateException
Subtask.exceptionNow()立即取异常未失败抛 IllegalStateException
Subtask.state()状态SUCCESS/FAILED/UNAVAILABLE
throwIfFailed()失败则抛旧 API(ShutdownOnFailure)
Joiner 策略结果聚合/失败处理JDK 25 新 API
  • 结构化并发 vs 其他方案:
维度ExecutorServiceCompletableFutureStructuredTaskScopeReactor
生命周期手动,孤儿任务可能链式,父可先返回词法作用域,父等子订阅生命周期
失败传播手动检查 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()
把长任务放进 scopescope 应短命长期任务用 Executor/调度器
  • 深挖点(面试官常追的 6 个):

    1. 结构化并发到底解决什么问题:它把“任务树”变成语言结构:子任务只能在父作用域内存在,父任务离开块前必须收口。对比 ExecutorService,不会出现父请求已返回、子任务还在写库的孤儿;对比 CompletableFuture,失败和取消有明确的传播路径,不依赖调用方记得 join 和观察异常。核心收益是生命周期、失败传播、取消、可观测性四件事一起收敛。
    2. 取消是怎么实现的:shutdown() 对未完成子任务调用中断,虚拟线程在 sleep/park/IO/queue 等阻塞点抛出 InterruptedException;纯 CPU 任务必须自己轮询中断标志。close() 会等待收口(或按版本语义关闭),所以 scope 应包在 try-with-resources 里;不要在 scope 外持有 Subtask 引用做延迟使用。
    3. API 为什么一直在变:结构化并发从 incubator 到多次 preview,ShutdownOnFailure/ShutdownOnSuccess 两个子类在 JEP 505 被 Joiner 策略取代,open() 成为入口,join() 直接返回聚合结果。这反映了“策略可组合”的设计方向。面试时不要背死某一种签名,要说清版本和设计意图;preview 需要 --enable-preview,生产慎用。
    4. ScopedValue 怎么实现继承:绑定不是写进每个线程的 map,而是构造一个不可变的绑定快照(Carrier/内部 Snapshot 链),作用域内线程读取当前快照;结构化并发 fork 子任务时把当前快照传给子任务,所以子任务能读到。普通线程没有这条传递路径,因此不继承。作用域退出只是恢复上一个快照,不需要清理,也不会有 ThreadLocal 的弱 key/强 value 泄漏问题。
    5. ScopedValue 为什么要求不可变:绑定在整个作用域内对所有线程可见且不能改;如果值是可变对象,多个子任务并发修改就等价于共享可变状态,需要额外同步。正确用法是传不可变 DTO、字符串、枚举或只读配置;需要可变状态时仍用 ThreadLocal、局部变量或显式参数。
    6. 和虚拟线程、CF、Reactor 怎么组合:虚拟线程提供轻量执行单元,结构化并发提供生命周期,ScopedValue 提供上下文,三者是分层关系。CompletableFuture 的扇出没有结构化保证,取消不传播,复杂请求编排建议换 scope;Reactor 有自己的 Context 和背压,不需要 ScopedValue。JDK 21+ 的推荐形态是“虚拟线程 + 结构化并发 + ScopedValue”的同步风格,而不是把回调链越写越深。
  • 追问链:

    1. 什么是结构化并发? → 用词法作用域约束子任务生命周期,父任务结束前子任务必须收口。
    2. 它和虚拟线程什么关系? → 正交:虚拟线程是轻量执行单元,结构化并发是任务生命周期管理。
    3. 它解决 ExecutorService 的什么问题? → 孤儿任务、取消不传播、异常丢失、任务树不可见。
    4. 它解决 CompletableFuture 的什么问题? → 失败/取消传播不明确、异常易被吞、父任务可先返回。
    5. 核心 API 是什么? → StructuredTaskScope + fork/join/joinUntil/shutdown/close。
    6. 子任务跑在什么线程上? → 早期预览版默认虚拟线程;后续版本按 Javadoc 确认。
    7. 父任务会等子任务吗? → 会,join() 等待全部完成或失败/超时。
    8. 子任务失败了会怎样? → 策略会取消其他子任务并让 scope 以失败收口。
    9. 取消怎么实现? → shutdown() 中断未完成子任务,依赖子任务在阻塞点响应中断。
  1. CPU 密集子任务能取消吗? → 只有检查 Thread.interrupted() 才能及时退出。
  2. 超时怎么做? → joinUntil(Instant),到点关闭 scope 并取消未完成子任务。
  3. resultNow 和 get 区别? → 前者不阻塞但要求已成功;后者阻塞等待。
  4. exceptionNow 什么时候能调? → 子任务已失败时;否则抛 IllegalStateException。
  5. state() 有哪些值? → SUCCESS/FAILED/UNAVAILABLE。
  6. scope 必须 close 吗? → 是,try-with-resources 保证收口,避免任务逃逸。
  7. 能在 scope 外使用结果吗? → 不建议,scope 关闭后结果不再受保护。
  8. ShutdownOnFailure 和 ShutdownOnSuccess 区别? → 前者任一失败即取消,后者任一成功即取消其余。
  9. JDK 25 的 API 变了吗? → 变了,JEP 505 用 open(Joiner),join() 返回聚合结果。
  10. 为什么 API 一直变? → 多次 preview,策略模型在演进;生产使用要锁版本。
  11. preview 怎么启用? → 编译和运行都加 --enable-preview。
  12. 结构化并发适合什么场景? → 请求级 fan-out、并行调用多个下游、需要失败/超时统一收口的场景。
  13. 不适合什么场景? → 长期后台任务、任务队列、fire-and-forget、需要背压的流式处理。
  14. 它能替代线程池吗? → 不能,scope 是短命的任务边界;线程池仍负责资源与队列。
  15. ScopedValue 是什么? → 不可变、作用域绑定、退出自动恢复的上下文传递机制。
  16. 怎么创建和绑定? → ScopedValue.newInstance() + ScopedValue.where(key, value).run/call。
  17. 作用域外读取会怎样? → get() 抛 NoSuchElementException,可用 isBound/orElse。
  18. 能绑定 null 吗? → 不能,key 或 value 为 null 会抛 NPE。
  19. 嵌套重绑定会怎样? → 内层遮蔽外层,退出内层恢复外层。
  20. ScopedValue 和 ThreadLocal 区别? → 不可变 vs 可变、词法作用域 vs 线程生命周期、自动恢复 vs 手动 remove。
  21. ScopedValue 会被子线程继承吗? → 结构化并发子任务会;普通线程和线程池不会。
  22. 为什么普通线程不继承? → 绑定通过 scope fork 传递,普通线程没有这条路径。
  23. ScopedValue 会泄漏吗? → 不会,作用域结束即恢复,没有每线程 map。
  24. 值可以是可变对象吗? → 技术上可以,但语义上是共享可变状态,应传不可变对象。
  25. ScopedValue 能替代 ThreadLocal 吗? → 不能完全替代,可变线程状态仍需 ThreadLocal。
  26. MDC 能自动读 ScopedValue 吗? → 不能,日志框架需显式桥接。
  27. CompletableFuture 能继承 ScopedValue 吗? → 不能,线程切换不会自动传递绑定。
  28. @Async 能继承吗? → 不能,需显式传参或装饰器。
  29. 虚拟线程下 ScopedValue 有什么优势? → 绑定共享、无每线程 map,海量虚拟线程不会放大内存。
  30. ScopedValue 的性能如何? → 读取轻量,绑定建立有成本;不要在高频循环里反复 where。
  31. 结构化并发怎么观测? → 线程 dump 看虚拟线程与任务树,JFR 看虚拟线程事件,按版本确认。
  32. 子任务里能用 ThreadLocal 吗? → 能,但每个虚拟线程一份 map,量大时内存放大。
  33. 怎么迁移现有 Executor 扇出? → 把 fan-out 收敛到 scope,统一超时/失败/取消,结果在 scope 内组装。
  34. 迁移风险是什么? → preview API 变化、子任务不响应中断、scope 过长、上下文传递遗漏。
  35. 和 Reactor 怎么选? → 请求级阻塞 fan-out 用结构化并发;流式/背压/复杂组合用 Reactor。
  36. 面试怎么总结? → 结构化并发管生命周期(父等子、失败取消、超时收口)→ 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 对比 → 虚拟线程下的内存优势 → 迁移与生产坑 → 选型收尾。