CKTIS / Java
Executors.newFixedThreadPool — grupo de hilos de tamaño fijo
Un grupo de tamaño 3 puede atender como máximo tres tareas a la vez, sin que tengan que empezar en el mismo instante. Si todos los hilos están ocupados, las tareas adicionales esperan en una cola.
Versión: Java SE 21
Sintaxis
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
// Static methods declared by Executors:
public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
// Example call:
ExecutorService pool = Executors.newFixedThreadPool(3);Executors.newFixedThreadPool es un método de fábrica estático de la clase java.util.concurrent.Executors. Devuelve un ExecutorService que reutiliza sus hilos de trabajo para distintas tareas. Con Executors.newFixedThreadPool(3) puede haber como máximo tres tareas en curso a la vez. Es un límite superior, no una garantía de que empiecen en el mismo instante, se ejecuten físicamente en paralelo o terminen en el orden en que se enviaron.
Si todos los hilos de trabajo están ocupados, las tareas adicionales esperan en una cola compartida sin límite de capacidad configurado. El tamaño del grupo limita los hilos, no las tareas en espera. Si las tareas siguen llegando más rápido de lo que el grupo las termina, la cola puede consumir cada vez más memoria. Para limitar la acumulación de tareas, usa un ThreadPoolExecutor con una cola acotada y una política de rechazo elegida expresamente.
La sobrecarga que solo recibe int nThreads usa la fábrica predeterminada, que crea hilos no demonio. La sobrecarga con ThreadFactory usa la fábrica proporcionada para crear hilos cuando hacen falta. Ambas lanzan IllegalArgumentException si nThreads <= 0; la segunda también lanza NullPointerException si la fábrica es null. Si un hilo termina por un fallo antes del cierre, el grupo lo sustituye si hace falta para ejecutar tareas posteriores.
Cierra el grupo cuando ya no lo necesites: los hilos creados por defecto pueden mantener activa la JVM. shutdown() deja de aceptar tareas nuevas, permite que se ejecuten las ya enviadas y no espera a que termine el grupo. En Java SE 21, try con recursos llama a close(), que inicia el cierre y espera hasta que el ejecutor termina.
Ejemplos
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FixedPoolDemo {
public static void main(String[] args)
throws InterruptedException, ExecutionException {
CountDownLatch started = new CountDownLatch(3);
CountDownLatch release = new CountDownLatch(1);
try (ExecutorService pool = Executors.newFixedThreadPool(3)) {
Callable<Void> holdWorker = () -> {
started.countDown();
release.await();
return null;
};
Future<Integer> fourth;
try {
for (int i = 0; i < 3; i++) {
pool.submit(holdWorker);
}
started.await();
fourth = pool.submit(() -> 4);
System.out.println("Fourth task done before release: " + fourth.isDone());
} finally {
release.countDown();
}
System.out.println("Fourth task result: " + fourth.get());
}
}
}Resultado
Fourth task done before release: false Fourth task result: 4
Cada una de las tres primeras tareas ocupa un hilo y no puede terminar hasta que se libere el bloqueo. Por eso, `isDone()` devuelve `false` para la cuarta. Tras la liberación, `get()` espera si es necesario al resultado `4`. El ejemplo muestra que las tareas se solapan, no que arranquen en el mismo instante.
Lecciones relacionadas
- Java · Lección 50 · Intermedio · Versión: 2
Fuentes
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int)
- Executors (Java SE 21 & JDK 21) — newFixedThreadPool(int, ThreadFactory)
- Executors (Java SE 21 & JDK 21) — defaultThreadFactory()
- ExecutorService (Java SE 21 & JDK 21)
- ThreadPoolExecutor (Java SE 21 & JDK 21) — queuing and resource use
- CountDownLatch (Java SE 21 & JDK 21)
- Future (Java SE 21 & JDK 21)