Java结构化并发优雅管理并发任务的新范式

Ja va 25 的结构化并发特性，是继虚拟线程之后又一个让并发编程更优雅的利器。

一、什么是结构化并发

结构化并发，说白了，是一种新的并发编程范式。它让并发任务的生命周期变得清晰可控，核心原则就一条：进作用域即启动，出作用域即结束。

想象一下，你正在组织一个团队项目，每个成员负责不同的任务。传统的并发编程就像让大家各自为战，任务何时开始、何时结束都很难追踪。而结构化并发就像给每个项目配备了项目经理，所有子任务都在明确的范围内管理，一目了然。

二、为什么需要结构化并发

传统的 Ja va 并发编程，问题不少。最常见的有这么几个：

• 任务泄漏：启动的线程或任务忘记关闭，资源白白浪费
• 取消困难：想取消一个任务，却发现它启动了一堆子任务，根本理不清
• 异常处理复杂：多个并发任务中，一个任务出错，其他任务怎么办？是继续还是取消？
• 代码可读性差：异步代码嵌套回调，读起来像迷宫，维护起来更是噩梦

结构化并发，正是冲着这些痛点来的。

三、Ja va 25 结构化并发的核心 API

1. StructuredTaskScope

这是结构化并发的核心类，它定义了一个任务范围——在这个范围内启动的所有子任务，都会自动纳入管理。比如，下面这段代码就展示了结构化的基本用法：

try (var scope = new StructuredTaskScope()) {
    // 在作用域内启动子任务
    Future userTask = scope.fork(() -> fetchUser(userId));
    Future orderTask = scope.fork(() -> fetchOrders(userId));
    // 等待所有任务完成
    scope.join();
    // 获取结果
    String user = userTask.resultNow();
    String orders = orderTask.resultNow();
    return processUserData(user, orders);
} // 作用域结束，所有子任务自动处理

注意那个 try-with-resources 结构——作用域一结束，所有子任务自动处理，不用你手动操心。

2. 不同的完成策略

Ja va 25 提供了多种 StructuredTaskScope 的实现，适用不同的业务场景：

ShutdownOnFailure：任一任务失败，立即取消其他任务。适合那种“一个掉链子，全盘都别干”的场景。

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future task1 = scope.fork(() -> callServiceA());
    Future task2 = scope.fork(() -> callServiceB());
    Future task3 = scope.fork(() -> callServiceC());
    scope.join();
    scope.throwIfFailed(); // 如果有任务失败，抛出异常
    return combineResults(
        task1.resultNow(),
        task2.resultNow(),
        task3.resultNow()
    );
}

ShutdownOnSuccess：任一任务成功，立即取消其他任务。适合“谁先到就用谁”的场景，比如缓存降级、多数据源查询。

try (var scope = new StructuredTaskScope.ShutdownOnSuccess()) {
    scope.fork(() -> fetchFromCache(key));
    scope.fork(() -> fetchFromDatabase(key));
    scope.fork(() -> fetchFromRemoteService(key));
    return scope.result(); // 返回第一个成功的结果
}

四、实践案例：电商订单查询优化

场景描述

电商平台的订单详情页，需要同时查询的信息可不少：

• 订单基本信息
• 商品详情
• 用户信息
• 物流信息
• 支付信息

传统做法要么串行查询，等着慢慢堆；要么用 CompletableFuture，但代码写起来又绕又乱。用结构化并发，可以这样实现：

public OrderDetail getOrderDetail(String orderId) {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Future orderFuture = scope.fork(() -> orderService.getOrder(orderId));
        Future> productsFuture = scope.fork(() -> productService.getProducts(orderId));
        Future userFuture = scope.fork(() -> userService.getUser(orderId));
        Future logisticsFuture = scope.fork(() -> logisticsService.getLogistics(orderId));
        Future paymentFuture = scope.fork(() -> paymentService.getPayment(orderId));
        scope.join();
        scope.throwIfFailed();
        return new OrderDetail(
            orderFuture.resultNow(),
            productsFuture.resultNow(),
            userFuture.resultNow(),
            logisticsFuture.resultNow(),
            paymentFuture.resultNow()
        );
    } catch (Exception e) {
        throw new OrderQueryException("Failed to fetch order details", e);
    }
}

这已经比传统方式优雅多了。如果再结合虚拟线程，并发还能更轻量：

public OrderDetail getOrderDetailOptimized(String orderId) {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        // 使用虚拟线程执行 IO 密集型任务
        Future orderFuture = scope.fork(() -> {
            Thread.startVirtualThread(() -> {}); // 确保使用虚拟线程
            return orderService.getOrder(orderId);
        });
        // 其他任务同样使用虚拟线程...
        scope.join();
        scope.throwIfFailed();
        return buildOrderDetail(orderFuture, productsFuture, userFuture, 
                               logisticsFuture, paymentFuture);
    }
}

五、异常处理的最佳实践

结构化并发让异常处理变得更加清晰。举个例子：

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future task1 = scope.fork(() -> {
        try {
            return service.call();
        } catch (ServiceException e) {
            // 可以在这里进行特定的异常处理
            logger.warn("Service call failed, using fallback", e);
            return fallbackResult;
        }
    });
    Future task2 = scope.fork(() -> anotherService.call());
    scope.join();
    // 统一处理失败情况
    try {
        scope.throwIfFailed();
    } catch (ExecutionException e) {
        // 转换为业务异常
        throw new BusinessException("Concurrent operation failed", e.getCause());
    }
    return combine(task1.resultNow(), task2.resultNow());
}

值得注意的是，这里异常传播是自动的——哪个任务失败，scope.throwIfFailed() 就会抛出对应的异常，完全不用你去手动追踪。

六、与传统并发方式的对比

从表格可以看出，结构化并发在多个维度上都有明显优势——尤其是在代码可读性和资源管理上，几乎是质的飞跃。

七、总结与建议

结构化并发是 Ja va 并发编程的一次重要进化。它让并发代码更加清晰、安全、易于维护。结合虚拟线程，我们可以构建出既高效又易读的并发程序。

最后，总结一下核心建议：在以下场景优先考虑使用结构化并发——

1. 需要同时发起多个独立请求：如微服务调用、数据查询
2. 需要快速失败：任一任务失败就取消其他任务
3. 需要快速返回：任一任务成功就返回结果
4. 需要明确的任务边界：子任务的生命周期与父任务紧密关联