Startseite / Concurrency / Scoped Values
Concurrency Experte

Scoped Values

Daten über den Aufruf-Stack sicher teilen ohne die Fallstricke von ThreadLocal.

Code-Vergleich
✕ 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);
}
Problem mit diesem Code entdeckt? Sag uns Bescheid.
Warum der moderne Weg gewinnt
🔒

Unveränderlich

Aufgerufene Methoden können den Scoped Value lesen, aber nie ändern.

🧹

Automatische Bereinigung

Kein manuelles remove() — der Wert ist auf den Block beschränkt.

⚡

Virtual-Thread-sicher

Funktioniert effizient mit Millionen von Virtual Threads.

Alter Ansatz
ThreadLocal
Moderner Ansatz
ScopedValue
Seit JDK
25
Schwierigkeitsgrad
Experte
JDK-Unterstützung
Scoped Values
Verfügbar

Finalisiert in JDK 25 LTS (JEP 506, Sept. 2025).

Wie es funktioniert

ScopedValue bietet unveränderlichen, vererbbaren, bereichsbegrenzten Kontext. Im Gegensatz zu ThreadLocal werden Scoped Values automatisch bereinigt, funktionieren mit Virtual Threads und können von aufgerufenen Methoden nicht verändert werden.

Zugehörige Dokumentation
Scoped Values (JEP 487) ↗ ScopedValue ↗
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

Structured concurrency

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());
}
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 ⬡