14 · Structured Concurrency & Scoped Values

// ❌ Unstructured: threads outlive their scope
ExecutorService executor = Executors.newFixedThreadPool(4);

// Submit tasks
executor.submit(() -> task1());
executor.submit(() -> task2());

// Main continues... but when do tasks finish?
// Main thread can exit while tasks still running
// Need manual join/shutdown logic

// ✅ Structured: clear scope and lifecycle
try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
    // Tasks are scoped to this try-with-resources
    scope.fork(() -> task1());
    scope.fork(() -> task2());
    // Main is blocked until all tasks complete
}  // Guaranteed: all tasks finished before continuing

// No lingering threads, clear resource management

import java.util.concurrent.StructuredTaskScope.*;

try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
    Subtask<String> subtask1 = scope.fork(() -> "result1");
    Subtask<String> subtask2 = scope.fork(() -> "result2");

    // Implicitly joins here when scope closes
}  // All subtasks guaranteed complete

// Retrieve results
String result1 = subtask1.get();
String result2 = subtask2.get();

try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
    scope.fork(() -> task1());
    scope.fork(() -> task2());
}  // Throws exception if any task fails

try (var scope = StructuredTaskScope.open(Joiner.failFast())) {
    scope.fork(() -> task1());
    scope.fork(() -> task2());  // If task1 fails, task2 cancelled
}  // Throws immediately on first failure

class BestResult<T> implements StructuredTaskScope.Joiner<T, T> {
    @Override
    public T result() { /* ... */ }

    @Override
    public void onComplete(Subtask<? extends T> subtask) { /* ... */ }
}

try (var scope = StructuredTaskScope.open(new BestResult<>())) {
    // ...
}

try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
    // Each fork creates a virtual thread automatically
    for (int i = 0; i < 1000; i++) {
        scope.fork(() -> blockingIoTask());
    }
}  // Waits for all 1000 virtual threads

private static ThreadLocal<RequestContext> context = new ThreadLocal<>();

public void handle(Request req) {
    context.set(new RequestContext(req.getId()));
    try {
        // Can access value from anywhere in call stack
        String id = context.get().id();
    } finally {
        context.remove();  // Manual cleanup needed
    }
}

import java.lang.ScopedValue;

private static final ScopedValue<RequestContext> context = ScopedValue.newInstance();

public void handle(Request req) {
    // Scoped explicitly — automatic cleanup
    context.set(new RequestContext(req.getId()), () -> {
        // Value available in this scope and all called methods
        String id = context.get().id();
        process();  // Can still call context.get() here
    });
    // Value cleaned up automatically after lambda
}

import java.util.concurrent.StructuredTaskScope.*;

try (var scope = StructuredTaskScope.open(Joiner.awaitAll())) {
    Subtask<String> task1 = scope.fork(() -> task1("ok"));
    Subtask<String> task2 = scope.fork(() -> task2("fail"));  // Throws

}  // Throws StructuredTaskScope.JoinedException
catch (StructuredTaskScope.JoinedException e) {
    for (Subtask<?> subtask : e.getExceptions()) {
        System.err.println("Task failed: " + subtask.exception());
    }
}

try (var scope = StructuredTaskScope.open(Joiner.failFast())) {
    scope.fork(() -> longRunningTask());
    scope.fork(() -> quickFailingTask());
    // If quickFailingTask fails immediately, longRunningTask is cancelled
}
catch (StructuredTaskScope.ShutdownException e) {
    // One task failed; others cancelled
}