Structured Concurrency

import java.util.concurrent.*;

record UserProfile(User user, List<Order> orders, AccountStatus status) {}

UserProfile fetchProfile(long userId) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

        // Fork three concurrent fetches
        Subtask<User>          userTask   = scope.fork(() -> userDb.find(userId));
        Subtask<List<Order>>   ordersTask = scope.fork(() -> orderDb.findByUser(userId));
        Subtask<AccountStatus> statusTask = scope.fork(() -> accountSvc.getStatus(userId));

        scope.join()           // wait for all three
             .throwIfFailed(); // if any threw, re-throw here

        // All succeeded — get results
        return new UserProfile(
            userTask.get(),
            ordersTask.get(),
            statusTask.get()
        );
    }
    // Scope closed: all subtasks guaranteed complete
    // If any failed: remaining were cancelled, exception propagated
}

String fetchWithHedging(String key) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {

        // Race three sources — first to succeed wins
        scope.fork(() -> primaryCache.get(key));
        scope.fork(() -> replicaDb.get(key));
        scope.fork(() -> slowPrimaryDb.get(key));

        scope.join(); // wait until first succeeds (or all fail)

        return scope.result(ex ->
            new RuntimeException("All sources failed for key: " + key, ex));
    }
    // Scope closed: losing subtasks were cancelled
}

// Timeout with structured concurrency
String fetchWithTimeout(String key) throws Exception {
    try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
        scope.fork(() -> fetchData(key));

        // joinUntil — deadline-based wait
        scope.joinUntil(Instant.now().plusSeconds(3));

        return scope.result(ex -> new TimeoutException("Fetch timed out"));
    }
}

// CompletableFuture — subtasks can outlive their logical scope
CompletableFuture<User>  userFuture  = fetchUserAsync(id);
CompletableFuture<Order> orderFuture = fetchOrderAsync(id);

// If userFuture fails and we don't cancel orderFuture,
// it keeps running and consuming resources indefinitely!
CompletableFuture.allOf(userFuture, orderFuture)
    .exceptionally(ex -> {
        orderFuture.cancel(true); // must remember to cancel manually
        return null;
    });

// Structured Concurrency — automatic lifetime management
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Subtask<User>  user  = scope.fork(() -> fetchUser(id));
    Subtask<Order> order = scope.fork(() -> fetchOrder(id));
    scope.join().throwIfFailed();
    // If either fails → both cancelled → scope closes cleanly
    // No manual cancellation needed
    process(user.get(), order.get());
}