Java 结构化并发：消除并发陷阱的革命性范式

// 问题1：线程泄漏 - 子线程的生命周期完全不受控制
void processOrders() {
    for (Order order : orders) {
        new Thread(() -> handleOrder(order)).start(); // 线程何时结束？永远不知道
    }
}

// 问题2：取消泄漏 - 父任务取消后，子任务仍在运行
Future<Result> search(Query q) {
    Future<List<Item>> items = executor.submit(() -> searchItems(q));
    Future<Price> price = executor.submit(() -> fetchPrice(q)); // 无关任务也被启动
    return combine(items.get(), price.get());
}

// 问题3：取消不确定性 - 哪个任务先完成？结果如何合并？
// 如果 items 先返回，但 price 还在运行，CPU 和内存被无谓占用

// JEP 428 核心 API：StructuredTaskScope
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future<String> user = scope.fork(() -> findUser());
    Future<Order> order = scope.fork(() -> fetchOrder());
    
    scope.join(); // 阻塞直到所有子任务完成或任一失败
    
    // 当作用域退出时，所有子任务都会被取消
    return new Result(user.resultNow(), order.resultNow());
} // ← 这里自动等待/取消所有子任务

// 场景：用户下单前需要同时验证库存、优惠券和支付渠道
// 任一验证失败，整个下单流程应快速失败
public OrderConfirmation placeOrder(Long userId, List<Long> itemIds) 
        throws ExecutionException, InterruptedException {
    
    try (var scope = new StructuredTaskScope.ShutdownOnFailure<Object>()) {
        Future<InventoryCheck> inventory = scope.fork(() -> 
            inventoryService.checkStock(itemIds));
        Future<CouponValidation> coupon = scope.fork(() -> 
            couponService.validate(userId));
        Future<PaymentAuth> payment = scope.fork(() -> 
            paymentService.authorize(userId));
        
        scope.join(); // 等待全部完成或任一失败
        scope.throwIfFailed(); // 如果有任何失败，抛出原异常
        
        return new OrderConfirmation(
            inventory.resultNow(),
            coupon.resultNow(), 
            payment.resultNow()
        );
    }
}

// 场景：从多个 CDN 节点并行获取资源，取最快响应
public byte[] fetchResource(String resourcePath) 
        throws ExecutionException, InterruptedException {
    
    try (var scope = new StructuredTaskScope.ShutdownOnSuccess<byte[]>()) {
        
        for (var endpoint : cdnEndpoints) {
            scope.fork(() -> cdnClient.fetch(endpoint, resourcePath));
        }
        
        scope.join(); // 阻塞直到任一任务成功，或所有任务失败
        
        return scope.resultNow(); // 获取最快结果
    }
}

// 自定义作用域：所有任务必须在指定时间内完成，否则全部取消
class TimeoutTaskScope<T> extends StructuredTaskScope<T> {
    
    private final Duration timeout;
    private final CountDownLatch done = new CountDownLatch(1);
    private volatile T result;
    private volatile Exception failure;
    
    public TimeoutTaskScope(Duration timeout) {
        this.timeout = timeout;
    }
    
    @Override
    public Future<T> fork(Callable<? extends T> task) {
        Future<T> future = super.fork(task);
        scheduleTimeout();
        return future;
    }
    
    private void scheduleTimeout() {
        Thread.ofVirtual().start(() -> {
            try {
                if (!done.await(timeout, TimeUnit.NANOSECONDS)) {
                    shutdown(); // 超时后取消所有任务
                }
            } catch (InterruptedException e) {
                shutdown();
            }
        });
    }
    
    @Override
    public void close() {
        done.countDown();
        super.close();
    }
}

// 高并发 HTTP 服务：每个请求使用虚拟线程处理
@Service
public class OrderService {
    
    private final StructuredTaskScope.ShutdownOnFailure scope = 
        new StructuredTaskScope.ShutdownOnFailure();
    
    // 每个请求启动一个虚拟线程处理，不再需要线程池
    public OrderDetail getOrderDetail(Long orderId) 
            throws ExecutionException, InterruptedException {
        
        try (scope) {
            Future<Order> order = scope.fork(() -> orderRepository.findById(orderId));
            Future<Customer> customer = scope.fork(() -> 
                customerService.getCustomer(order.resultNow().getCustomerId()));
            Future<List<Payment>> payments = scope.fork(() -> 
                paymentService.getPayments(orderId));
            
            scope.join();
            scope.throwIfFailed();
            
            return new OrderDetail(
                order.resultNow(),
                customer.resultNow(),
                payments.resultNow()
            );
        }
    }
}