Home / Concurrency / Valori scoped
Concurrency Avanzato

Valori scoped

Condividi dati attraverso gli stack di chiamate in modo sicuro senza le insidie di ThreadLocal.

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

Immutabile

I chiamati possono leggere ma non modificare mai il valore scoped.

🧹

Pulizia automatica

Nessun remove() manuale — il valore è scoped al blocco.

⚡

Sicuro per thread virtuali

Funziona efficientemente con milioni di thread virtuali.

Approccio Vecchio
ThreadLocal
Approccio Moderno
ScopedValue
Dal JDK
25
Difficoltà
Avanzato
Supporto JDK
Valori scoped
Disponibile

Finalizzato nel JDK 25 LTS (JEP 506, settembre 2025).

Come funziona

ScopedValue fornisce contesto immutabile, ereditabile e limitato allo scope. A differenza di ThreadLocal, i valori scoped vengono puliti automaticamente, funzionano con i thread virtuali e non possono essere mutati dai chiamati.

Documentazione Correlata
Scoped Values (JEP 487) ↗ ScopedValue ↗
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

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