当前位置：首页 > news >正文

JDK 21 并发编程 - 教程

news 2026/5/12 2:57:55

文章目录

前言
一、虚拟线程（Virtual Threads）：让 “多线程” 不再昂贵
二、结构化并发（Structured Concurrency）：让多任务协作 “有条理”
三、虚拟线程 + 结构化并发：强强联合
总结

前言

Java 的并发并发模型在 JDK 21 迎来了 “革命性升级”，核心是解决传统并发编程的两大痛点：线程资源昂贵导致的高并发瓶颈和多任务协作混乱导致的代码复杂。这两个问题，JDK 21 分别用 “虚拟线程” 和 “结构化并发” 给出了答案。

一、虚拟线程（Virtual Threads）：让 “多线程” 不再昂贵

传统并发的痛点：线程是 “重量级资源”
传统 Java 线程（平台线程）直接对应操作系统线程，创建一个线程要占用 1MB 左右内存，且操作系统能同时运行的线程数量有限（通常几千个）。如果遇到高并发场景（比如 10 万用户同时访问接口），线程池会瞬间耗尽，导致请求排队甚至失败。

比如下面的代码，用线程池处理 10 万任务，会因线程不足变得很慢：

// 传统线程池（最多 1000 个平台线程）
ExecutorService executor = Executors.newFixedThreadPool(1000);
// 模拟 10 万次 I/O 操作（如数据库查询、网络请求）
for (int i = 0; i < 100000; i++) {
executor.submit(() -> {
// 模拟 I/O 等待（比如查数据库）
Thread.sleep(100); // 此时线程完全空闲，但仍占用资源
return null;
});
}

原因：10 万任务要排队等待 1000 个线程，大部分时间线程在 “空等” I/O 结果，却浪费着宝贵的系统资源。

虚拟线程的解决方案：轻量级线程，数量 “几乎无限”

虚拟线程是 JVM 管理的 “轻量级线程”，不直接绑定操作系统线程。一个平台线程可以 “承载” 成千上万个虚拟线程，且创建成本极低（内存仅几 KB）。

核心优势：当虚拟线程执行 I/O 操作（如 sleep、数据库查询）时，JVM 会 “暂时释放” 它占用的平台线程，让其他虚拟线程使用。等 I/O 完成后，再重新分配一个平台线程继续运行。

// 虚拟线程池（自动管理，数量无上限）
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
// 同样处理 10 万次 I/O 操作
for (int i = 0; i < 100000; i++) {
executor.submit(() -> {
Thread.sleep(100); // 虚拟线程等待时，平台线程会被释放
return null;
});
}

效果：10 万任务几乎同时启动，无需排队，因为虚拟线程不占用宝贵的平台线程资源，I/O 等待时会 “让出” 资源给其他任务。
通俗理解

平台线程 = 一辆满载的卡车，跑起来费油（资源），一次只能拉少量货物（任务）。
虚拟线程 = 自行车队，轻便灵活， thousands of 辆自行车可以共享一条马路（平台线程），I/O 等待时还会主动下车让道。

二、结构化并发（Structured Concurrency）：让多任务协作 “有条理”

传统并发的痛点：多任务 “各自为政”，容易出乱子

当一个任务需要拆分多个子任务并行执行时（比如接口需要同时调用 3 个微服务，再汇总结果），传统写法会有两个问题：
1.子任务失败了，其他子任务还在瞎跑，浪费资源；
2.需要手动处理异常和线程关闭，代码臃肿。

比如下面的代码，假设 fetchUser() 失败，fetchOrder() 和 fetchCart() 还会继续执行：

// 传统方式：三个子任务并行执行
ExecutorService executor = Executors.newFixedThreadPool(3);
Future<User> userFuture = executor.submit(() -> fetchUser());Future<Order> orderFuture = executor.submit(() -> fetchOrder());Future<Cart> cartFuture = executor.submit(() -> fetchCart());try {User user = userFuture.get(); // 等待用户信息Order order = orderFuture.get(); // 等待订单信息Cart cart = cartFuture.get(); // 等待购物车信息return new Result(user, order, cart);} catch (Exception e) {// 手动取消所有子任务（容易遗漏）userFuture.cancel(true);orderFuture.cancel(true);cartFuture.cancel(true);throw e;}

结构化并发的解决方案：子任务 “荣辱与共”
结构化并发将多个子任务视为一个 “整体”，用 StructuredTaskScope 管理：

父任务等待所有子任务完成；
任何一个子任务失败，自动取消其他子任务；
无需手动关闭线程，自动释放资源。

案例：子任务失败自动取消其他任务

// 结构化并发：子任务绑定到一个“作用域”
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
// 启动三个子任务（fork = 分叉执行）
Future<User> userFuture = scope.fork(() -> fetchUser());Future<Order> orderFuture = scope.fork(() -> fetchOrder());Future<Cart> cartFuture = scope.fork(() -> fetchCart());scope.join(); // 等待所有子任务完成scope.throwIfFailed(); // 若有子任务失败，直接抛出异常// 所有任务成功，汇总结果return new Result(userFuture.result(),orderFuture.result(),cartFuture.result());}

效果：如果 fetchUser() 抛出异常，scope.join() 会发现失败，自动调用 shutdown() 取消 fetchOrder() 和 fetchCart()，避免资源浪费。

通俗理解

传统并发 = 三个朋友各自去买奶茶，其中一个人没买到，另外两个人还在傻傻排队。
结构化并发 = 三个人组队买奶茶，队长（父任务）说：“有人没买到，大家都别买了，赶紧回来！”

三、虚拟线程 + 结构化并发：强强联合

案例：高并发接口同时调用多个服务

// 处理用户请求的接口
public Result handleRequest() throws Exception {
// 1. 创建虚拟线程的结构化作用域
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
// 2. 用虚拟线程启动子任务（默认使用虚拟线程）
Future<User> userFuture = scope.fork(() -> fetchUser()); // 调用用户服务Future<Order> orderFuture = scope.fork(() -> fetchOrder()); // 调用订单服务Future<Cart> cartFuture = scope.fork(() -> fetchCart()); // 调用购物车服务// 3. 等待所有子任务完成，失败则取消其他任务scope.join();scope.throwIfFailed();// 4. 汇总结果return new Result(userFuture.result(),orderFuture.result(),cartFuture.result());}}