Accueil / Concurrency / Valeurs à portée
Concurrency Avancé

Valeurs à portée

Partagez des données le long de la pile d'appels en toute sécurité sans les problèmes de ThreadLocal.

Comparaison de Code
✕ 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);
}
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🔒

Immutable

Les méthodes appelées peuvent lire mais jamais modifier la valeur à portée.

🧹

Nettoyage automatique

Sans remove() manuel — la valeur est limitée au bloc.

⚡

Compatible avec les threads virtuels

Fonctionne efficacement avec des millions de threads virtuels.

Ancienne Approche
ThreadLocal
Approche Moderne
ScopedValue
Depuis JDK
25
Difficulté
Avancé
Support JDK
Valeurs à portée
Disponible

Finalisé dans JDK 25 LTS (JEP 506, sept. 2025).

Comment ça fonctionne

ScopedValue fournit un contexte immutable, héritable et limité à une portée. Contrairement à ThreadLocal, les valeurs à portée sont nettoyées automatiquement, fonctionnent avec les threads virtuels et ne peuvent pas être modifiées par les méthodes appelées.

Documentation Associée
Scoped Values (JEP 487) ↗ ScopedValue ↗
Patterns associés
Concurrency Débutant

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Survolez pour voir le moderne ➜
JDK 21+ →
Concurrency Avancé

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());
}
Survolez pour voir le moderne ➜
JDK 25+ →
Concurrency Avancé

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();
}
Survolez pour voir le moderne ➜
JDK 25+ →
Partager 𝕏 🦋 in ⬡