Home / Concurrency / Concorrenza strutturata
Concurrency Avanzato

Concorrenza strutturata

Gestisci i cicli di vita dei task concorrenti come un'unica unità di lavoro.

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

Nessuna perdita di thread

Tutti i task biforcati completano prima che lo scope si chiuda.

⚡

Fallimento rapido

ShutdownOnFailure annulla i fratelli se uno fallisce.

📐

Struttura chiara

Il ciclo di vita del task corrisponde allo scope lessicale nel codice.

Approccio Vecchio
Ciclo di vita del thread manuale
Approccio Moderno
StructuredTaskScope
Dal JDK
25
Difficoltà
Avanzato
Supporto JDK
Concorrenza strutturata
Anteprima

Anteprima nel JDK 25 (quinta anteprima, JEP 505). Richiede --enable-preview.

Come funziona

La concorrenza strutturata tratta un gruppo di task concorrenti come un'unica operazione. Se un subtask fallisce, gli altri vengono annullati. Lo scope garantisce che non ci siano perdite di thread e fornisce chiare relazioni padre-figlio.

Documentazione Correlata
Structured Concurrency (JEP 499) ↗ StructuredTaskScope ↗
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

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+ →
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 ⬡