Home / Concurrency / Inizializzazione lazy senza lock
Concurrency Avanzato

Inizializzazione lazy senza lock

Sostituisci il double-checked locking con StableValue per singleton lazy.

Confronto Codice
✕ 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();
    }
}
Vedi un problema con questo codice? Faccelo sapere.
Perché vince l'approccio moderno
🧹

Nessun boilerplate

Nessun volatile, synchronized o doppio controllo null.

⚡

Letture più veloci

La JVM può piegare le costanti dopo l'inizializzazione.

✅

Provabilmente corretto

Nessun bug di ordinamento sottile — la JVM lo gestisce.

Approccio Vecchio
synchronized + volatile
Approccio Moderno
StableValue
Dal JDK
25
Difficoltà
Avanzato
Supporto JDK
Inizializzazione lazy senza lock
Anteprima

Anteprima nel JDK 25 (JEP 502, StableValue). Richiede --enable-preview.

Come funziona

StableValue incapsula il pattern di inizializzazione lazy con la corretta thread safety. La JVM può ottimizzare il percorso di lettura dopo l'inizializzazione, rendendolo potenzialmente più veloce delle letture volatile.

Documentazione Correlata
StableValue (JEP 502) ↗ StableValue ↗
Pattern correlati
Concurrency Principiante

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Passa il mouse per vedere il moderno ➜
JDK 21+ →
Concurrency Avanzato

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());
}
Passa il mouse per vedere il moderno ➜
JDK 25+ →
Concurrency Avanzato

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);
}
Passa il mouse per vedere il moderno ➜
JDK 25+ →
Condividi 𝕏 🦋 in ⬡