Java: What is Structured Concurrency in Java?

Structured Concurrency — manages concurrent tasks with clear lifecycle (Java 21+ preview).

Key idea:

• Child tasks must complete before parent.
• Clean error propagation.
• Automatic cancellation.
• Prevents orphaned threads and resource leaks.

1try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
2    Subtask<String> user = scope.fork(() -> fetchUser());
3    Subtask<Order>  order = scope.fork(() -> fetchOrder());
4
5    scope.join();            // Wait for both
6    scope.throwIfFailed();   // Propagate errors
7
8    return new Response(user.get(), order.get());
9}

ShutdownOnFailure:

• If any task fails, cancel all others.
• Propagates first exception.
• Ensures all child tasks complete before parent.

ShutdownOnSuccess:

• If any task succeeds, cancel others.
• Returns first successful result.
• Useful for racing multiple strategies.

How it works step-by-step:

1. Create a scope with a policy (ShutdownOnFailure or ShutdownOnSuccess).
2. Fork child tasks within the scope.
3. Call scope.join() to wait for all tasks to complete.
4. If using ShutdownOnFailure, call scope.throwIfFailed() to propagate errors.
5. Retrieve results from subtasks.
6. When the try-with-resources block exits, the scope ensures all tasks are cleaned up.

Real-world example:

1public Response getUserDashboard(Long userId) {
2    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
3        Subtask<User> userTask = scope.fork(() -> userService.getUser(userId));
4        Subtask<List<Order>> ordersTask = scope.fork(() -> orderService.getOrders(userId));
5        Subtask<Stats> statsTask = scope.fork(() -> statsService.getStats(userId));
6
7        scope.join();
8        scope.throwIfFailed();
9
10        return new Response(userTask.get(), ordersTask.get(), statsTask.get());
11    } catch (Exception e) {
12        throw new DashboardException("Failed to load dashboard", e);
13    }
14}

Benefits:

• No orphaned tasks.
• Clear error handling.
• Easier to reason about.
• Automatic resource cleanup.

System design context:

• Ideal for microservice orchestrations where multiple downstream calls happen in parallel.
• Prevents resource leaks in long-running services.
• Simplifies error propagation across concurrent tasks.

Common pitfalls:

• Forgetting throwIfFailed(): Errors may be silently swallowed.
• Long-running tasks: May block the parent thread unnecessarily.
• Resource management: Ensure all resources are properly closed within the scope.