Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

ExecutorService — tareas, resultados y cierre

ExecutorService separa el envío de tareas de la gestión de su ejecución. Aprende a usar submit, la ejecución por lotes con invokeAll y shutdown, y la diferencia entre solicitar el cierre y esperar a que termine.

Versión: Java SE 21 (repository runtime); production runtime not attested

Sintaxis

<T> Future<T> submit(Callable<T> task)
Future<?> submit(Runnable task)
<T> Future<T> submit(Runnable task, T result)
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException
void shutdown()

java.util.concurrent.ExecutorService amplía Executor con seguimiento de resultados y gestión de la terminación. Esta entrada se refiere a Java SE 21, el entorno de ejecución del repositorio. No se ha confirmado el entorno de ejecución en producción.

ExecutorService.submit devuelve un Future: para Callable<T>, proporciona el resultado de la tarea; para Runnable, el resultado es null; y para submit(Runnable, T), es el valor proporcionado. Future.get() espera si es necesario; informa de los fallos de la tarea mediante ExecutionException, de la cancelación mediante CancellationException y de una interrupción durante la espera mediante InterruptedException.

ExecutorService.invokeAll sin límite de tiempo espera a que terminen todas las tareas Callable. Los futures devueltos conservan el orden de entrada, no el orden de finalización. Que una tarea termine no significa que haya tenido éxito: obtén resultados y errores mediante get().

ExecutorService.shutdown rechaza nuevas tareas, permite que se ejecuten las aceptadas anteriormente y no espera. Usa awaitTermination para esperar; en Java SE 21, close() dentro de try-with-resources cierra el servicio y espera. El shutdown() explícito del ejemplo muestra la API, pero resulta redundante debido a close(). Las tareas de larga duración pueden retrasar el cierre.

El ejemplo usa Executors.newFixedThreadPool(2). Esta fábrica tiene una cola ilimitada: dos hilos no limitan el número de tareas en espera. No la consideres una protección automática frente a la sobrecarga.

Ejemplos

import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService pool = Executors.newFixedThreadPool(2)) {
            Future<Integer> single = pool.submit(() -> 6 * 7);
            List<Callable<Integer>> tasks = List.of(() -> 2 + 3, () -> 4 * 5);
            List<Future<Integer>> batch = pool.invokeAll(tasks);
            pool.shutdown();

            System.out.println(single.get());
            for (Future<Integer> result : batch) {
                System.out.println(result.get());
            }
        }
    }
}

Resultado

42
5
20

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes