Accueil / Concurrency / Initialisation paresseuse sans verrous
Concurrency Avancé

Initialisation paresseuse sans verrous

Remplace le double-checked locking par StableValue pour les singletons paresseux.

Comparaison de Code
✕ Java 8 
class Config {
    private static volatile Config inst;
    static Config get() {
        if (inst == null) {
            synchronized (Config.class) {
                if (inst == null)
                    inst = load();
            }
        }
        return inst;
    }
}
✓ Java 25 (Preview) 
class Config {
    private static final
        StableValue<Config> INST =
            StableValue.of(Config::load);

    static Config get() {
        return INST.get();
    }
}
Un problème avec ce code ? Dites-le nous.
Pourquoi la méthode moderne gagne
🧹

Sans code répétitif

Sans volatile, synchronized ni double-null-check.

⚡

Lectures plus rapides

La JVM peut plier les constantes après l'initialisation.

✅

Correction démontrable

Sans erreurs subtiles d'ordonnancement — la JVM s'en charge.

Ancienne Approche
synchronized + volatile
Approche Moderne
StableValue
Depuis JDK
25
Difficulté
Avancé
Support JDK
Initialisation paresseuse sans verrous
Aperçu

Aperçu dans JDK 25 (JEP 502, StableValue). Nécessite --enable-preview.

Comment ça fonctionne

StableValue encapsule le pattern d'initialisation paresseuse avec une sécurité thread correcte. La JVM peut optimiser le chemin de lecture après l'initialisation, le rendant potentiellement plus rapide que les lectures volatile.

Documentation Associée
StableValue (JEP 502) ↗ StableValue ↗
Preuve
Voir la preuve source ↗
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é

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