Inicio / Concurrency / Concurrencia estructurada
Concurrency Avanzado

Concurrencia estructurada

Gestiona el ciclo de vida de tareas concurrentes como una única unidad de trabajo.

Comparación de Código
✕ 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());
}
¿Ves un problema con este código? Cuéntanos.
Por qué gana la forma moderna
🛡️

Sin fugas de hilos

Todas las tareas bifurcadas terminan antes de que se cierre el ámbito.

⚡

Fallo rápido

ShutdownOnFailure cancela las tareas hermanas si una falla.

📐

Estructura clara

El ciclo de vida de la tarea coincide con el ámbito léxico en el código.

Enfoque Antiguo
Ciclo de vida manual de hilos
Enfoque Moderno
StructuredTaskScope
Desde JDK
25
Dificultad
Avanzado
Soporte JDK
Concurrencia estructurada
Preview

Preview en JDK 25 (quinta preview, JEP 505). Requiere --enable-preview.

Cómo funciona

La concurrencia estructurada trata un grupo de tareas concurrentes como una sola operación. Si alguna subtarea falla, las demás se cancelan. El ámbito garantiza que no haya fugas de hilos y establece relaciones claras padre-hijo.

Documentación Relacionada
Structured Concurrency (JEP 499) ↗ StructuredTaskScope ↗
Patrones relacionados
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();
Pasa el ratón para ver el moderno ➜
JDK 21+ →
Concurrency Avanzado

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);
}
Pasa el ratón para ver el moderno ➜
JDK 25+ →
Concurrency Avanzado

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();
}
Pasa el ratón para ver el moderno ➜
JDK 25+ →
Compartir 𝕏 🦋 in ⬡