知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 结构化并发与 StructuredTaskScope > 导读:本文从"把一次请求拆成几个子任务并发执行后,线程泄漏、取消不传播、异常被吞、错误处理到处散落"这一组具体痛点出发,把结构化并发的思想、`StructuredTaskScope` 的基本用法、两种关闭策略、取消传播与异常聚合语义、和 `CompletableFuture`/`ExecutorService` 的定位差异,以及它的预览特性与版本演进逐项讲透。适合已经会写 `CompletableFuture` 或线程池、想搞清楚"结构化并发到底解决什么问题"的 Java 后端同学。 > 重要前提:结构化并发在 JDK 21 起是一个**预览 API(preview API)**,需要 `--enable-preview` 才能编译运行,且规范在多个版本中持续演进,**API 的名称与形态可能随版本变化**。本文所有示例都要**结合你实际使用的 JDK 版本确认**,不要直接照搬到生产。 ## 一、先建立全局认知 ### Q:什么是结构化并发(Structured Concurrency)? A:结论先行——结构化并发是把**一组相关的并发子任务当作一个整体**:它们有明确的作用域(scope),随作用域建立而启动、随作用域退出而全部结束;父任务不会在子任务还没结束前就继续往下走,因此子任务的生命周期被"结构"限定了。 先给术语: - **结构化并发(structured concurrency)**:一种并发编程范式,要求并发子任务的生命周期被语法块(作用域)严格约束,不允许出现"父任务已经返回、子任务还在后台跑"的孤儿任务。 - **作用域(scope)**:承载一组子任务的生命周期边界,在 Java 中由 `StructuredTaskScope` 表示,配合 `try-with-resources` 使用。 - **子任务(subtask)**:在作用域内 fork 出来、代表一次并发工作单元的任务。 可以类比结构化编程:`if`、`for`、`while` 这些块有明确的"进入"和"退出",退出之后块内的局部变量不再存在。结构化并发把同样的纪律带到并发上——**块退出之后,块内启动的线程一定已经结束**。  *图:结构化并发与 StructuredTaskScope:作用域内的 fork / join* ```text 单线程结构化: 非结构化并发(易泄漏): void handle() { void handle() { A(); executor.submit(A); // 谁负责等它? B(); executor.submit(B); // 父方法随时可能返回 C(); } // 子任务可能还在后台跑 → 孤儿任务 } } 结构化并发(作用域约束): handle() { ┌── scope ──────────────────────────┐ │ fork A ──┐ │ │ fork B ──┤ 并发执行 │ │ └── join 等待全部结束 │ └────────────────────────────────────┘ // 走出这个块时,A、B 一定都已结束(完成或取消) 继续处理结果 } ``` ### Q:结构化并发具体解决了哪些问题? A:结论先行——它针对性地解决四类在"手工并发"里反复出现的问题:**线程泄漏、取消不传播、异常被吞、错误处理分散**。下面逐条对照。 **问题一:线程泄漏(thread leak)** 用 `ExecutorService.submit()` 提交任务后,如果提交方因为超时、异常提前返回,或者忘了处理结果,那些任务仍会继续跑,甚至永久阻塞在某个 IO 上。它们不会被自动回收,慢慢耗尽线程和资源。 结构化并发的处理:作用域退出时**强制等待所有子任务结束**,未完成的会被取消。没有任何子任务能在作用域关闭后继续存活。 **问题二:取消不传播(cancellation does not propagate)** 设想父任务并发调用三个下游。第一个失败了,父任务其实已经不需要另外两个的结果,但手工写法里这两个任务会继续跑完——白白消耗下游容量。或者父任务被取消(比如调用方超时),子任务却不知道,继续占用资源。 结构化并发的处理:作用域采用"失败关闭"策略时,**任一子任务失败会立即取消其余子任务**,并且当外层线程被中断时,取消语义会向下传播。 **问题三:异常被吞(exceptions swallowed)** `Future` 的异常被包在 `ExecutionException` 里,如果调用方只 `get()` 了一个 Future、忽略了另一个,或者 catch 住没记录日志,失败就静默消失了。多子任务场景下"到底该抛哪个异常"也没有统一答案。 结构化并发的处理:作用域提供**集中的异常聚合语义**——由策略决定是"任一失败即整体失败并抛出首个异常",还是"首个成功即返回"。 **问题四:错误处理分散(scattered error handling)** 手工写法里,每个 `Future` 各自 try/catch、各自判空、各自超时,代码又长又容易漏。结构化并发把"等待、判断失败、取消其余、抛哪个异常"收敛到作用域的 `join()` 一处。 ### Q:结构化并发和虚拟线程(Virtual Thread)是什么关系? A:结论先行——它们是**互补**关系:虚拟线程解决"线程便宜、能开很多"的问题,结构化并发解决"开了很多之后,怎么保证它们有始有终、不泄漏"的问题。二者常一起使用,但彼此独立——结构化并发也可以运行在平台线程上。 为什么互补?虚拟线程让"为每个子任务开一个线程"变得廉价,于是你会更愿意把一个请求拆成多个并发子任务。但子任务一多,"谁等它们""失败怎么办""取消怎么传"就成了新难题——这正是结构化并发的职责。官方材料中也常把结构化并发描述为与虚拟线程非常契合的搭配。 补充一个实现细节:JDK 中的 `StructuredTaskScope.fork()` **默认使用虚拟线程**来执行子任务(fork 会启动一个新线程承载子任务),也可以通过配置传入自己的 `ThreadFactory` 改变这一点。该默认行为**需结合所用 JDK 版本确认**。 ## 二、理解核心机制 ### Q:`StructuredTaskScope` 的基本模型是什么? A:结论先行——核心是一个固定的使用循环:**打开作用域 → fork 子任务 → join 等待 → 处理结果/异常 → 关闭作用域**,且打开作用域的线程是"所有者线程(owner thread)",`fork/join/close` 都只能由它调用。 ```text 使用循环(配合 try-with-resources): 1. open :打开作用域,当前线程成为 owner 2. fork :为每个子任务启动一个线程(默认虚拟线程) 3. join :作为"一个整体操作"等待子任务,按策略决定何时结束等待 4. 处理结果 :读取子任务结果,或处理 join 抛出的异常 5. close :取消作用域(若尚未取消),中断未完成子任务,等待所有线程结束 ``` 几条必须遵守的规则(不同版本细节可能有差异,以所用版本为准): - `fork`、`join`、`close` 只能由 **owner 线程**调用;子任务线程不能操作作用域。 - `join` 只能在 `fork` 之后调用,且**只能调用一次**;`join` 之后不能再 `fork`。 - 如果 fork 过子任务却没调用 `join`,`close` 会抛异常——这是刻意的设计,防止你"忘了等"。 - 作用域通过 `try-with-resources` 关闭;关闭时会取消未完成子任务并**等待所有子任务线程真正结束**。  *图:owner 线程与三个子任务线程的作用域边界* ```text 作用域内外的关系: owner 线程 │ open + fork + join + close 之间不会"溜走" ├── VT-1 子任务 ├── VT-2 子任务 └── VT-3 子任务 close 返回时:所有子任务线程必已终止(或已完成、或已被取消并结束) ``` ### Q:`fork()` 返回的 `Subtask` 是什么?和 `Future` 有什么区别? A:结论先行——`Subtask` 是作用域内子任务的句柄,用来**在 `join` 之后读取结果或异常、查看状态**;它不是 `Future`,不提供阻塞式 `get(timeout)` 那套独立等待语义,因为"等待"这件事已经被提到作用域层面统一做了。 关键 API(JDK 21 预览版的形态): - `Subtask.get()`:返回结果;仅当子任务成功完成时可用,否则抛 `IllegalStateException`。 - `Subtask.state()`:返回 `Subtask.State`,取值含 `SUCCESS`、`FAILED`、`UNAVAILABLE`。 - `Subtask.exception()`:返回失败原因(未失败时为 `null`)。 设计意图是:**"等待所有子任务"是作用域级的操作,单个子任务不该各自阻塞**。这样"何时结束等待"就由策略统一决定,避免了手工写法里"逐个 `get()`、顺序不同结果不同"的混乱。 ### Q:两种关闭策略(ShutdownOnFailure / ShutdownOnSuccess)分别是什么语义? A:结论先行——它们对应两种最常见的并发编排模式: - **`ShutdownOnFailure`(失败即关闭)**:任一子任务失败,就取消其余子任务、唤醒 owner。适合"**所有**结果都必需"的场景(invoke-all)。等价于"要么全部成功,要么整体失败"。 - **`ShutdownOnSuccess`(成功即关闭)**:任一子任务成功,就取消其余子任务、唤醒 owner。适合"**多个来源任取其一**"的场景,例如多个镜像/副本里谁先返回用谁。 对照表: | 维度 | ShutdownOnFailure | ShutdownOnSuccess | | --- | --- | --- | | 触发关闭的条件 | 任一子任务失败 | 任一子任务成功 | | 典型语义 | 全部成功才继续(invoke all) | 取首个成功结果(race) | | 结果获取 | 全部子任务成功后逐个 `get()` | `result()` 取首个成功结果 | | 失败处理 | 抛出(如 `throwIfFailed()`) | 全部失败时抛出 | | 适用例子 | 并行查用户 + 并行查订单,缺一不可 | 多机房查询取最快返回 | **使用边界**:如果业务其实对失败有容忍(比如"三个推荐源返回两个也行"),这两种现成策略都不完全贴合,需要自定义策略或退回更基础的 `join` + 手动判断 `Subtask.state()`。 ## 三、基本用法与版本演进 ### Q:JDK 21 上的写法长什么样?请给出可编译思路的示例。 A:结论先行——JDK 21 预览版通过**子类构造**选择策略:`new StructuredTaskScope.ShutdownOnFailure()` 或 `new StructuredTaskScope.ShutdownOnSuccess<>()`,在 `try` 块内 `fork`,然后 `join`。 下面示例用"并行获取用户与订单,缺一不可"演示 `ShutdownOnFailure`。**注意:这是预览 API,编译与运行都需要 `--enable-preview`,并且必须在相同 JDK 版本上编译和运行。** ```java import java.util.concurrent.StructuredTaskScope; import java.util.concurrent.StructuredTaskScope.Subtask; // 目标:并行获取用户信息和订单信息,任一失败则整体失败 // 编译:javac --release 21 --enable-preview -d out Demo.java // 运行:java --enable-preview -cp out Demo record User(String name) {} record Order(String id) {} public class Demo { static User fetchUser(long id) throws InterruptedException { Thread.sleep(200); // 模拟下游调用 return new User("user-" + id); } static Order fetchOrder(long id) throws InterruptedException { Thread.sleep(200); return new Order("order-" + id); } static String handle(long id) throws Exception { // ShutdownOnFailure:任一子任务失败 → 取消其余 → 唤醒 owner try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { Subtask<User> userTask = scope.fork(() -> fetchUser(id)); Subtask<Order> orderTask = scope.fork(() -> fetchOrder(id)); scope.join(); // 等待“全部成功”或“首个失败” scope.throwIfFailed(); // 若有子任务失败,抛出聚合后的异常 // 走到这里说明两个子任务都成功 return "OK: " + userTask.get().name() + " / " + orderTask.get().id(); } // close():取消(若尚未取消)并等待所有子任务线程结束 } public static void main(String[] args) throws Exception { System.out.println(handle(7L)); } } ``` 关键点与预期行为: - `scope.fork(() -> ...)` 为每个子任务启动一个线程(默认虚拟线程),返回 `Subtask`。 - `join()` 会**阻塞**,直到"全部成功"或"任一失败"。若任一失败,其余子任务会被取消。 - `throwIfFailed()` 把失败集中抛出(若全部成功则什么都不做);不调用它,你就得自己遍历 `Subtask.state()` 判断。 - 出 `try` 块时自动 `close()`:取消未完成子任务并等待线程结束。**这正是"不泄漏"的保证**。 **适用**:缺一不可的聚合式调用。**不适用**:需要"容忍部分失败"的场景——`ShutdownOnFailure` 遇到第一个失败就整体失败,不会等你凑齐"够用的结果"。 ### Q:"多个来源任取其一"该用哪个策略? A:结论先行——用 `ShutdownOnSuccess`:首个成功的子任务会立刻让 `join()` 返回,其余子任务被取消;如果全部失败,取结果时会抛出异常。 ```java import java.util.concurrent.StructuredTaskScope; import java.util.concurrent.StructuredTaskScope.Subtask; // 目标:多个数据源谁先返回用谁 // 编译/运行同样需要 --enable-preview(且同版本编译与运行) public class RaceDemo { static String query(String source) throws InterruptedException { Thread.sleep(100 + (long) (Math.random() * 300)); // 模拟不同延迟 return "result-from-" + source; } static String fastest() throws Exception { try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) { scope.fork(() -> query("A")); scope.fork(() -> query("B")); scope.fork(() -> query("C")); scope.join(); // 首个成功即返回,其余被取消 return scope.result(); // 取首个成功结果;全部失败则抛异常 } } public static void main(String[] args) throws Exception { System.out.println(fastest()); } } ``` 关键点: - `ShutdownOnSuccess<T>` 是泛型子类,`result()` 返回首个成功子任务的结果。 - 首个成功会取消其余子任务,避免它们继续占用下游资源。 - 全部失败时 `result()` 会抛出异常(可传入异常转换函数定制抛出的类型,具体 API 形态**需结合版本确认**)。 **使用边界**:适合"多副本/多源竞速"。如果几个来源返回的东西语义不同(比如一个查缓存、一个查数据库),"谁快用谁"可能带回不同质量的数据,要谨慎。 ### Q:这个 API 在后续版本里变了什么?为什么我要特别小心版本? A:结论先行——**结构化并发从 JDK 21 起一直是预览 API,并经历了多轮预览,其中一个重要变化是:从"用子类构造函数选策略"改为"用静态工厂 `open(...)` + `Joiner` 选策略"**。因此同一段代码在不同 JDK 版本上可能编译不过,必须按你的 JDK 版本查对应的 API 文档。 演进线索(均为预览,最终形态以所用版本为准): - JDK 21(JEP 453,首个预览):`fork()` 从返回 `Future` 改为返回 `Subtask`;用 `ShutdownOnFailure` / `ShutdownOnSuccess` 两个子类表达策略;`fork` 默认启动虚拟线程。 - JDK 22、23、24:继续预览,API 基本保持一致(以对应 JEP 为准)。 - 较新的版本:`StructuredTaskScope` 形态调整为**密封接口**,通过静态工厂 `open()` 打开,用 `Joiner` 表达策略;常见的 `Joiner` 工厂方法包括 `allSuccessfulOrThrow()`、`anySuccessfulResultOrThrow()`、`awaitAllSuccessfulOrThrow()`、`awaitAll()` 等。示例形态大致如下(**示意,务必以所用版本文档为准**): ```java // 目标:较新版本形态示意 —— 用 open + Joiner 表达“全部成功或抛出” // 注意:这是预览 API 的“较新形态示意”,是否可用取决于你的 JDK 版本 import java.util.concurrent.StructuredTaskScope; import java.util.concurrent.StructuredTaskScope.Subtask; public class NewFormDemo { static String fetch(String src) throws InterruptedException { Thread.sleep(150); return "data-" + src; } static void run() throws Exception { try (var scope = StructuredTaskScope.open( StructuredTaskScope.Joiner.<String>allSuccessfulOrThrow())) { Subtask<String> a = scope.fork(() -> fetch("A")); Subtask<String> b = scope.fork(() -> fetch("B")); scope.join(); // 全部成功或任一失败即返回/抛出 System.out.println(a.get() + " + " + b.get()); } } } ``` 请注意:上面的 `open(...)`、`Joiner`、以及 `open()` 零参默认策略(默认行为常被描述为"全部成功或任一失败")都属于**预览 API**,属性、方法名、返回类型可能随版本调整。**不要把这段代码想当然地当成跨版本通用写法**。 ### Q:编译和运行预览 API 需要哪些开关? A:结论先行——需要**在编译和运行两个阶段都显式启用预览特性**,并且编译与运行必须使用**同一个 JDK 版本**。 ```bash # 编译:启用预览(注意 --source/--release 与你的 JDK 版本匹配) javac --release 21 --enable-preview -d out Demo.java # 运行:同样需要 --enable-preview java --enable-preview -cp out Demo ``` 要点: - 只加运行的开关、编译不加(或反之)都会失败。 - 预览特性在**不同 JDK 版本间不保证二进制/源码兼容**,跨版本升级时编译报错是常态,不是"你写错了"。 - 依赖预览特性的库,会把这一约束传递给使用者——这也是很多团队对"预览 API 上生产"持谨慎态度的原因。 **适用建议**:可以在评估、原型、内部工具中使用;上生产前必须确认目标运行环境的 JDK 版本、以及未来升级 JDK 时的改造成本。 ## 四、取消传播与异常聚合语义 ### Q:取消(cancellation)是怎么传播的? A:结论先行——取消传播有三条路径:**子任务失败触发策略取消**(ShutdownOnFailure/ShutdownOnSuccess)、**作用域关闭时取消未完成子任务**、以及**owner 线程被中断时向上/向下的联动**;取消的手段是**中断(interrupt)**运行子任务的线程。  *图:一个子任务 failed 后中断兄弟任务并唤醒 owner* ```text 取消传播示意(失败即关闭策略): fork A ─────failed────┐ fork B ──(中断)──┐ │ fork C ──(中断)──┤ │ ▼ ▼ join() 返回/抛出,owner 被唤醒 close() ──> 再次确保未完成子任务被取消并等待其结束 ``` 关键点: - 传播方式是 `Thread.interrupt()`,因此**子任务代码必须正确响应中断**(例如阻塞调用会抛 `InterruptedException`,循环里应检查中断状态),否则取消会"不生效"——这是最常见的失败原因。 - 不要吞掉 `InterruptedException`。正确的处理是:要么向上抛出,要么重新设置中断标志(`Thread.currentThread().interrupt()`)后退出。 - "取消"不等于"立即停止":Java 没有强制杀死线程的机制(`Thread.stop` 已废弃且不安全),所以取消是**协作式**的。 ### Q:异常是如何聚合的? A:结论先行——作用域不会把每个子任务的异常都抛给你,而是**由策略决定抛哪一个**:失败即关闭策略通常抛出**首个失败**子任务的异常;成功即关闭策略只有在**全部失败**时才抛异常。`join()` 本身还可能抛 `InterruptedException`(owner 被中断)。 需要理解的两个层次: 1. **子任务层**:每个 `Subtask` 自己记录成功/失败与异常(`state()`、`exception()`),互不影响。 2. **作用域层**:`join()`/结果获取方法把"整体结论"聚合后交给 owner——成功就是成功,失败就抛一个代表性异常。 **使用边界**:如果你需要"完整收集所有失败原因"(比如批量校验、聚合报错),现成的"抛首个异常"语义不够用,需要遍历所有 `Subtask.exception()` 自行聚合,而不是指望 `join()` 直接给你一个异常列表。 ## 五、与 CompletableFuture、ExecutorService 的定位对比 ### Q:结构化并发和 `CompletableFuture` 有什么区别? A:结论先行——`CompletableFuture` 擅长**异步编排与组合**(链式 `thenApply`/`thenCompose`/`allOf`,回调驱动),但它**不限定任务的生命周期**;结构化并发擅长**限定一组并发任务的生命周期与失败传播**,不负责复杂的异步流水线。 对照表: | 维度 | CompletableFuture | StructuredTaskScope | | --- | --- | --- | | 主要目标 | 异步组合、流水线、回调 | 生命周期约束、取消与异常聚合 | | 生命周期边界 | 无(谁等它由你负责) | 有(作用域退出即全部结束) | | 取消传播 | 需手动 `cancel`,且不保证级联 | 由策略自动取消其余子任务 | | 异常处理 | `CompletionException` 包裹,易被忽略 | `join` 处集中抛出 | | 适合场景 | 多阶段异步转换、组合多个异步源 | "一次请求拆成几个子任务,要么全成要么全败/取首个成功" | | 线程模型 | 依赖所选的 Executor | 默认虚拟线程(可配置) | 两者并不互斥:你可以用结构化并发管理"一次请求内的并发子任务边界",而在某个子任务内部用 `CompletableFuture` 做异步编排。 ### Q:和手工用 `ExecutorService` 管理相比,优势在哪? A:结论先行——手工 `ExecutorService` 把"提交、等待、超时、取消、汇总异常"这些**责任全压给开发者**,而结构化并发把它们**收敛进一个语法块**,并用 `close()` 强制"有始有终",从设计上消除孤儿任务。 手工写法的典型隐患: ```java // 目标:手工并发调用两个下游——能跑,但“取消/清理/异常”全靠自觉 // 注意:这是对比示例,请关注它需要手工处理的几件事 Future<User> fu = executor.submit(() -> fetchUser(id)); Future<Order> fo = executor.submit(() -> fetchOrder(id)); User user; try { user = fu.get(1, TimeUnit.SECONDS); } catch (TimeoutException e) { fu.cancel(true); // 必须记得取消,否则任务可能继续跑 throw e; } // 如果这里抛异常提前返回,fo 很可能变成“孤儿任务”继续执行 Order order = fo.get(1, TimeUnit.SECONDS); ``` 对比结构化并发的写法,同样的需求由 `try (var scope = ...)` 块表达:**不需要你记得取消、不需要你保证等待**,因为 `close()` 会兜底。 **使用边界**:`ExecutorService` 仍然是通用基础设施,需要长期存活的线程池、复杂调度、周期性任务时依然用它;结构化并发更适合"**一次调用内**的一组短期并发子任务"。 ## 小结 - 结构化并发把一组并发子任务当作一个整体,用作用域约束其生命周期:**作用域退出 = 子任务全部结束**。 - 它针对四类老问题:线程泄漏、取消不传播、异常被吞、错误处理分散。 - `StructuredTaskScope` 使用循环固定:open → fork → join → 处理 → close,且 `fork/join/close` 只能由 owner 调用,`join` 只能调一次。 - 两种经典策略:`ShutdownOnFailure`(全成或全败)与 `ShutdownOnSuccess`(取首个成功);较新版本改用 `open(...)` + `Joiner` 表达策略。 - 取消靠 `Thread.interrupt()` 协作式传播,子任务必须正确响应中断;异常由策略聚合,通常抛"首个失败"或"全部失败时抛"。 - 与 `CompletableFuture`(编排)、`ExecutorService`(通用基础设施)是**互补**关系,不是替代。 - **务必记住:这是预览 API,需要 `--enable-preview`,API 随版本演进,需结合所用 JDK 版本确认后再上生产。** ## 思考题 1. 结构化并发解决了"线程泄漏",它是靠哪一步(open/fork/join/close 中的哪个)兜底的?为什么这个设计能防止"忘了等"? 2. 一个子任务吞掉了 `InterruptedException` 且不退出,会对"取消传播"造成什么后果?你会如何排查? 3. `ShutdownOnFailure` 和 `CompletableFuture.allOf` 都表达"全部完成",它们在生命周期与异常语义上的差别是什么? 4. 如果业务需要"收集所有失败原因",现有策略够用吗?你会怎么改造? 5. 为什么预览 API"跨 JDK 版本升级时编译报错是常态"?这对你的技术选型意味着什么?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入