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

CKTIS / Java

ThreadPoolExecutor: grupo acotado y CallerRunsPolicy

ThreadPoolExecutor gestiona un grupo de hilos y una cola de tareas. Aprende cuándo crea hilos o pone tareas en cola, cómo ThreadPoolExecutor.CallerRunsPolicy gestiona la sobrecarga y cómo shutdown() y awaitTermination() permiten una terminación ordenada.

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

Sintaxis

new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, new ThreadPoolExecutor.CallerRunsPolicy());
executor.execute(task);
executor.shutdown();
executor.awaitTermination(timeout, unit);

ThreadPoolExecutor ejecuta tareas mediante hilos de un grupo. Al enviar una tarea, crea un hilo si el número de trabajadores es inferior a corePoolSize; de lo contrario, intenta ponerla en cola. Cuando la cola está llena, puede crear hilos hasta el límite de maximumPoolSize y, después, aplica la política de rechazo. Una cola sin límite normalmente impide que el grupo crezca por encima de corePoolSize y puede acumular una cantidad ilimitada de tareas pendientes.

ThreadPoolExecutor.CallerRunsPolicy ejecuta sincrónicamente una tarea rechazada en el hilo que llama a execute, salvo que el executor se haya cerrado. Esto ralentiza al productor de tareas, pero puede bloquear, por ejemplo, un hilo que atiende solicitudes. El límite del grupo no incluye estas ejecuciones en el hilo llamante. Después del cierre, esta política descarta la tarea en silencio en lugar de lanzar una excepción, por lo que no garantiza que se ejecute.

ThreadPoolExecutor.shutdown inicia un cierre ordenado: se ejecutan las tareas aceptadas previamente, pero no se aceptan tareas nuevas. No espera a que terminen; para ello, usa awaitTermination y comprueba su resultado. shutdownNow() solo intenta interrumpir los hilos, así que las tareas deben responder a las interrupciones. El ejemplo usa un mecanismo de sincronización, en vez de retrasos, para provocar la sobrecarga. Ámbito: Java SE 21; no se certifica el entorno de ejecución del repositorio ni el de producción.

Ejemplos

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch release = new CountDownLatch(1);
        AtomicInteger completed = new AtomicInteger();
        Thread caller = Thread.currentThread();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                1, 1, 0L, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1),
                new ThreadPoolExecutor.CallerRunsPolicy());

        try {
            executor.execute(() -> {
                try {
                    release.await();
                    completed.incrementAndGet();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            executor.execute(() -> completed.incrementAndGet());
            executor.execute(() -> {
                System.out.println("caller thread: "
                        + (Thread.currentThread() == caller));
                completed.incrementAndGet();
            });
        } finally {
            release.countDown();
            executor.shutdown();
        }

        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                throw new IllegalStateException("Termination timed out");
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
            throw e;
        }
        System.out.println("completed: " + completed.get());
    }
}

Resultado

caller thread: true
completed: 3

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