Startseite / Concurrency / Strukturierte Nebenläufigkeit
Concurrency Experte

Strukturierte Nebenläufigkeit

Den Lebenszyklus nebenläufiger Aufgaben als eine einzige Arbeitseinheit verwalten.

Code-Vergleich
✕ Java 8 
ExecutorService exec =
    Executors.newFixedThreadPool(2);
Future<User> u = exec.submit(this::fetchUser);
Future<Order> o = exec.submit(this::fetchOrder);
try {
    return combine(u.get(), o.get());
} finally { exec.shutdown(); }
✓ Java 25 (Preview) 
try (var scope = new StructuredTaskScope
        .ShutdownOnFailure()) {
    var u = scope.fork(this::fetchUser);
    var o = scope.fork(this::fetchOrder);
    scope.join().throwIfFailed();
    return combine(u.get(), o.get());
}
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
🛡️

Keine Thread-Lecks

Alle verzweigten Aufgaben werden abgeschlossen, bevor der Scope geschlossen wird.

⚡

Schnelles Versagen

ShutdownOnFailure bricht Geschwister-Aufgaben ab, wenn eine fehlschlägt.

📐

Klare Struktur

Der Aufgaben-Lebenszyklus entspricht dem lexikalischen Scope im Code.

Alter Ansatz
Manueller Thread-Lebenszyklus
Moderner Ansatz
StructuredTaskScope
Seit JDK
25
Schwierigkeitsgrad
Experte
JDK-Unterstützung
Strukturierte Nebenläufigkeit
Vorschau

Preview in JDK 25 (fünfte Preview, JEP 505). Erfordert --enable-preview.

Wie es funktioniert

Strukturierte Nebenläufigkeit behandelt eine Gruppe nebenläufiger Aufgaben als eine einzige Operation. Schlägt eine Teilaufgabe fehl, werden die anderen abgebrochen. Der Scope stellt sicher, dass keine Threads verloren gehen, und schafft klare Eltern-Kind-Beziehungen.

Zugehörige Dokumentation
Structured Concurrency (JEP 499) ↗ StructuredTaskScope ↗
Verwandte Muster
Concurrency Einsteiger

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Hover für Modernes ➜
JDK 21+ →
Concurrency Experte

Scoped values

Java 8
static final ThreadLocal<User> CURRENT =
    new ThreadLocal<>();
void handle(Request req) {
    CURRENT.set(authenticate(req));
    try { process(); }
    finally { CURRENT.remove(); }
}
Java 25
static final ScopedValue<User> CURRENT =
    ScopedValue.newInstance();
void handle(Request req) {
    ScopedValue.where(CURRENT,
        authenticate(req)
    ).run(this::process);
}
Hover für Modernes ➜
JDK 25+ →
Concurrency Experte

Stable values

Java 8
private volatile Logger logger;
Logger getLogger() {
    if (logger == null) {
        synchronized (this) {
            if (logger == null)
                logger = createLogger();
        }
    }
    return logger;
}
Java 25 (Preview)
private final StableValue<Logger> logger =
    StableValue.of(this::createLogger);

Logger getLogger() {
    return logger.get();
}
Hover für Modernes ➜
JDK 25+ →
Teilen 𝕏 🦋 in ⬡