Structured concurrency in Java

Tasks as one unit

Structured concurrency treats a group of related subtasks as one unit of work, scoped to a code block. Subtasks can't outlive their scope, so no orphan threads leak. Status check: in Java 25, StructuredTaskScope is still a preview API, needing --enable-preview, and its design has changed between previews.

open, fork, join, get

open() creates the scope. fork(task) starts a subtask in a new virtual thread. join() waits for the subtasks according to the scope's policy. Then get() reads each result. Try-with-resources guarantees cleanup.

try (var scope = StructuredTaskScope.open()) {
    var user = scope.fork(() -> findUser(id));
    var cart = scope.fork(() -> findCart(id));
    scope.join();
    return new Page(user.get(), cart.get());
}

Unstructured vs structured

var u = pool.submit(() -> fetchUser(id));
var o = pool.submit(() -> fetchOrders(id));
return new Page(u.get(), o.get());

try (var s = StructuredTaskScope.open()) {
    var u = s.fork(() -> fetchUser(id));
    var o = s.fork(() -> fetchOrders(id));
    s.join();
    return new Page(u.get(), o.get());
}

var a = scope.fork(() -> 20);
a.get();       // IllegalStateException!
scope.join();
a.get();       // fine: 20

Policies

open() with no arguments uses the default policy: all must succeed, and the first failure cancels the rest. Other policies can be plugged in, such as "first success wins" for racing two replicas. Either way, the scope, not you, tracks every thread it started.

Key takeaways

Practice questions

try (var scope = StructuredTaskScope.open()) {
    var user = scope.fork(() -> findUser(id));
    var cart = scope.fork(() -> findCart(id));
    scope.___();
    return new Page(user.get(), cart.get());
}

Next: ThreadLocal's successor. Scoped values share a read-only value with everything a call touches, then vanish on their own.