Saltar al contenido
NextPatch Blog

La concurrencia estructurada sale de preview en JDK 28

El JEP 543 está Targeted para JDK 28 y StructuredTaskScope deja de ser preview tras varias versiones de cambios. Así queda la API y qué tienes que tocar si ya la usabas con --enable-preview.

Java 4 min de lectura

Si llevas tiempo mirando StructuredTaskScope de reojo porque no querías meter --enable-preview en producción, ya queda poco: el JEP 543, Structured Concurrency, está Targeted para JDK 28 desde el 21 de octubre. En la documentación de los early-access de JDK 28, la API ya aparece sin la marca de preview.

Ha costado llegar. StructuredTaskScope está en preview desde JDK 21 y la API se ha rehecho por el camino: en la documentación de JDK 27, open() y open(Joiner) constan desde JDK 25, open(Joiner, UnaryOperator) desde JDK 26 y open(UnaryOperator) desde JDK 27. Si la probaste en 21 y la dejaste, lo que vas a encontrar se parece poco.

La idea, en un ejemplo

Lanzas varias subtareas dentro de un bloque, esperas a que terminen y, si una falla, las demás se cancelan. Nada se queda corriendo fuera del try.

java
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Subtask;

record CustomerView(Customer customer, List<Order> orders) {}

CustomerView loadView(long id) throws ExecutionException, InterruptedException {
    try (var scope = StructuredTaskScope.open()) {
        Subtask<Customer> customer = scope.fork(() -> customerRepo.find(id));
        Subtask<List<Order>> orders = scope.fork(() -> orderRepo.byCustomer(id));

        scope.join(); // si una falla, se cancela la otra y salta ExecutionException

        return new CustomerView(customer.get(), orders.get());
    }
}

open() sin argumentos aplica la política más habitual: o todas bien, o la primera que falle. Si todas terminan, join() devuelve null y lees cada resultado con get(). Si una falla, join() lanza ExecutionException con la excepción original como causa, y las subtareas que seguían en marcha se cancelan con una interrupción.

Por defecto, cada subtarea corre en un virtual thread sin nombre. Si necesitas otra cosa, withThreadFactory te deja poner la tuya.

Los Joiners deciden cuándo se acaba

La política se cambia pasando un Joiner a open. Las fábricas de StructuredTaskScope.Joiner en JDK 28 son estas:

  • awaitAllSuccessfulOrThrow(): la del ejemplo anterior; join() devuelve null.
  • allSuccessfulOrThrow(): join() devuelve una List<T> con todos los resultados.
  • anySuccessfulOrThrow(): gana el primer resultado correcto; solo falla si fallan todas.
  • allUntil(Predicate): devuelve todas las subtareas y cancela cuando el predicado lo dice; los fallos no hacen que join() lance nada.

Las tres primeras tienen una variante que recibe un Function<Throwable, R_X> para elegir qué excepción lanza join(). Para eso sirve el tercer parámetro de tipo de StructuredTaskScope<T, R, R_X extends Throwable>.

Un caso típico: pedir lo mismo a dos réplicas, quedarte con la primera y no esperar más de dos segundos.

java
import java.time.Duration;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Joiner;

String fetchFastest(String key) throws ExecutionException, InterruptedException {
    try (var scope = StructuredTaskScope.open(
            Joiner.<String>anySuccessfulOrThrow(),
            cfg -> cfg.withTimeout(Duration.ofSeconds(2)))) {
        scope.fork(() -> mirrorA.fetch(key));
        scope.fork(() -> mirrorB.fetch(key));
        return scope.join(); // gana la primera que responde; la otra se cancela
    }
}

Si salta el timeout, join() lanza ExecutionException y la causa es una StructuredTaskScope.CancelledByTimeoutException. La configuración admite también withName para dar nombre al scope.

Si ya la usabas en preview

La declaración de la interfaz, la firma de join() y los nombres de los Joiners que usamos aquí son los mismos en la preview de JDK 27 y en el early-access de JDK 28. Así que, si tu código compila hoy con --enable-preview en JDK 27, lo razonable es que al pasar a JDK 28 solo tengas que quitar --enable-preview de javac y de java.

Targeted significa que el JEP está planificado para JDK 28, y la documentación de los early-access avisa de que la especificación aún no es final. Prueba tu código con una build de JDK 28 antes de dar nada por hecho.

En NextPatch

La ruta Java 23 → 25: la LTS que cierra el catálogo tiene una lección dedicada a la quinta preview, la que estrenó StructuredTaskScope.open() y los Joiners. Es la base de lo que ahora se queda como definitivo.

Pasa de leerlo a practicarlo.

Un resumen de 45 segundos y un reto de dos minutos al día. La cuenta es gratis y guarda tu XP, tu racha y tus insignias.

Crear cuenta gratis