Accueil / Concurrency / Concurrence structurée
Concurrency Avancé

Concurrence structurée

Gérez le cycle de vie des tâches concurrentes comme une seule unité de travail.

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

Sans fuites de threads

Toutes les tâches bifurquées se terminent avant la fermeture de la portée.

⚡

Échec rapide

ShutdownOnFailure annule les tâches sœurs si l'une échoue.

📐

Structure claire

Le cycle de vie de la tâche correspond à la portée lexicale dans le code.

Ancienne Approche
Cycle de vie manuel des threads
Approche Moderne
StructuredTaskScope
Depuis JDK
25
Difficulté
Avancé
Support JDK
Concurrence structurée
Aperçu

Aperçu dans JDK 25 (cinquième aperçu, JEP 505). Nécessite --enable-preview.

Comment ça fonctionne

La concurrence structurée traite un groupe de tâches concurrentes comme une seule opération. Si une sous-tâche échoue, les autres sont annulées. La portée garantit qu'il n'y a pas de fuites de threads et établit des relations claires parent-enfant.

Documentation Associée
Structured Concurrency (JEP 499) ↗ StructuredTaskScope ↗
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é

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