CKTIS / Java
Grupos de hilos fijos, capacidad de la cola y cierre ordenado
Crea dos grupos de dos hilos, compara los límites de sus colas y recoge los resultados antes de llamar a `shutdown()` en ambos.
Versión: Java SE 21
Sintaxis
In java.util.concurrent:
public static ExecutorService Executors.newFixedThreadPool(int nThreads)
public static ExecutorService Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
void ExecutorService.shutdown()
public void ThreadPoolExecutor.shutdown()
Bounded-queue alternative:
new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy())En Java SE 21, el método estático Executors.newFixedThreadPool(2) de java.util.concurrent devuelve un ExecutorService que reutiliza hilos de trabajo. Como máximo dos hilos procesan tareas a la vez. Si ambos están ocupados, las tareas adicionales esperan en una cola compartida sin un límite de capacidad configurado. Limitar los hilos no limita, por tanto, las tareas pendientes. Si las tareas llegan más rápido de lo que el grupo las termina, la cola puede crecer y consumir más memoria.
La sobrecarga Executors.newFixedThreadPool(nThreads, threadFactory) utiliza la ThreadFactory proporcionada para crear hilos, pero no limita la cola. Ambas sobrecargas lanzan IllegalArgumentException si nThreads <= 0; la segunda lanza NullPointerException si la fábrica es null.
Para limitar la acumulación de tareas, configura un ThreadPoolExecutor con tamaño básico y máximo de 2 y una ArrayBlockingQueue<>(2). Así pueden ejecutarse hasta dos tareas en los hilos del grupo y esperar hasta otras dos en la cola. Si el grupo no puede aceptar una tarea porque ambos hilos están ocupados y la cola está llena, AbortPolicy lanza RejectedExecutionException en lugar de esperar a que haya espacio. También rechaza las tareas enviadas después de iniciarse el cierre.
ExecutorService.shutdown() define el contrato de cierre ordenado y ThreadPoolExecutor.shutdown() lo implementa: las tareas ya aceptadas pueden ejecutarse, las nuevas se rechazan y la llamada no espera a que terminen. Repetir la llamada no tiene efecto adicional. Puede producirse una SecurityException si un gestor de seguridad activo deniega el permiso. En la ruta normal, recoge todos los resultados necesarios con Future.get() antes de cerrar ambos grupos en finally, que se ejecuta incluso si hay un fallo. get() espera a una tarea concreta si es necesario; para esperar con un límite de tiempo a que termine todo el grupo tras shutdown(), usa awaitTermination().
Ejemplos
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class PoolDemo {
public static void main(String[] args)
throws InterruptedException, ExecutionException {
ExecutorService fixed = Executors.newFixedThreadPool(2);
ThreadPoolExecutor bounded = new ThreadPoolExecutor(
2, 2, 0L, TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<>(2), new ThreadPoolExecutor.AbortPolicy());
try {
Future<Integer> first = fixed.submit(() -> 2);
Future<Integer> second = fixed.submit(() -> 3);
Future<Integer> third = bounded.submit(() -> 5);
Future<Integer> fourth = bounded.submit(() -> 7);
int fixedSum = first.get() + second.get();
int boundedSum = third.get() + fourth.get();
System.out.println("fixed=" + fixedSum + ", bounded=" + boundedSum);
} finally {
try {
fixed.shutdown();
} finally {
bounded.shutdown();
}
}
}
}Resultado
fixed=5, bounded=12
El programa envía dos tareas a cada grupo y, en la ruta normal, recoge los cuatro resultados antes del cierre. Imprime solo las dos sumas, una por grupo, en un orden fijo con independencia de cómo se planifiquen los hilos. No fuerza que se llene la cola ni que se rechace una tarea.
Lecciones relacionadas
- Java · Lección 42 · Avanzado · Versión: 2
Fuentes
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int)
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int, ThreadFactory)
- ExecutorService (Java SE 21 & JDK 21) — shutdown(), submit(), and awaitTermination()
- ThreadPoolExecutor (Java SE 21 & JDK 21) — queuing and task rejection
- ThreadPoolExecutor (Java SE 21 & JDK 21) — shutdown()
- ThreadPoolExecutor.AbortPolicy (Java SE 21 & JDK 21)
- ArrayBlockingQueue (Java SE 21 & JDK 21) — fixed queue capacity
- Future (Java SE 21 & JDK 21) — get()