Java Academy · Lección

ExecutorService y tipos de grupos de hilos

Cree grupos de hilos fijos, en caché, individuales y programados, y comprenda cuándo usar cada uno.

Lección 1 de 413 pasos

ExecutorService y tipos de grupos de hilos es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

¿Por qué usar grupos de hilos?

Crear un Thread nuevo para cada tarea es costoso: crear y destruir hilos implica una sobrecarga. Un grupo de hilos reutiliza un conjunto fijo de hilos para ejecutar muchas tareas, lo que reduce la sobrecarga y permite controlar el consumo de recursos.

import java.util.concurrent.*;

// Bad practice: new thread per task
new Thread(() -> System.out.println("task")).start();

// Better: reuse threads from a pool
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> System.out.println("task from pool"));
pool.shutdown();

newFixedThreadPool

Crea un grupo con exactamente N hilos. Las tareas adicionales se ponen en cola hasta que haya un hilo disponible. Es adecuado cuando conoce el nivel de paralelismo deseado.

ExecutorService pool = Executors.newFixedThreadPool(4);

for (int i = 0; i < 10; i++) {
    final int taskId = i;
    pool.submit(() -> {
        System.out.println("Task " + taskId + " on " + Thread.currentThread().getName());
    });
}

pool.shutdown();
pool.awaitTermination(10, TimeUnit.SECONDS);

newCachedThreadPool

Crea hilos bajo demanda y reutiliza los que están inactivos. Los hilos que permanecen inactivos durante 60 segundos se terminan. Es adecuado para muchas tareas de corta duración, pero resulta arriesgado para tareas de larga duración o ilimitadas, ya que puede agotar la memoria.

ExecutorService cached = Executors.newCachedThreadPool();

for (int i = 0; i < 100; i++) {
    cached.submit(() -> {
        // quick task
        double result = Math.sqrt(Math.random());
    });
}
cached.shutdown();

newSingleThreadExecutor

Un grupo con exactamente un hilo. Las tareas se ejecutan secuencialmente en el orden en que se envían. Es adecuado para serializar el acceso a un recurso compartido.

ExecutorService single = Executors.newSingleThreadExecutor();

single.submit(() -> System.out.println("Task 1"));
single.submit(() -> System.out.println("Task 2"));
single.submit(() -> System.out.println("Task 3"));
// Always prints: Task 1, Task 2, Task 3 (sequential)
single.shutdown();

newScheduledThreadPool

Admite tareas programadas y recurrentes. Úselo para sondeos, reintentos y tareas de mantenimiento en segundo plano.

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

// One-shot delay
scheduler.schedule(() -> System.out.println("Delayed!"),
    3, TimeUnit.SECONDS);

// Fixed rate (every 2 seconds)
scheduler.scheduleAtFixedRate(
    () -> System.out.println("Tick"),
    0, 2, TimeUnit.SECONDS);

// Run later: scheduler.shutdown();

VirtualThreadExecutor (Java 21+)

Java 21 introduce los hilos virtuales: son ligeros y baratos de crear. Use Executors.newVirtualThreadPerTaskExecutor() para cargas de trabajo con un uso intensivo de E/S:

// Java 21+
try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        final int id = i;
        exec.submit(() -> {
            Thread.sleep(100); // blocks without tying up OS thread
            System.out.println("vthread " + id);
        });
    }
} // auto-shutdown

Elegir el grupo adecuado

Directrices:

Tareas limitadas por la CPU: grupo fijo con N = número de núcleos de CPU
Tareas limitadas por E/S: grupo en caché o hilos virtuales
Tareas secuenciales: ejecutor de un solo hilo
Tareas programadas o recurrentes: grupo de hilos programados

int cores = Runtime.getRuntime().availableProcessors();
ExecutorService cpuPool = Executors.newFixedThreadPool(cores);
System.out.println("Pool size: " + cores);

ThreadPoolExecutor personalizado

Para obtener un control detallado, cree directamente un ThreadPoolExecutor:

ThreadPoolExecutor tpe = new ThreadPoolExecutor(
    2,           // corePoolSize
    10,          // maximumPoolSize
    60L,         // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100), // work queue
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.CallerRunsPolicy() // rejection policy
);
tpe.submit(() -> System.out.println("Custom pool task"));
tpe.shutdown();

Apagado ordenado

Cierre siempre ExecutorService para liberar los hilos. shutdown() deja de aceptar tareas nuevas, pero completa las que están en cola. shutdownNow() intenta cancelar las tareas en ejecución.

ExecutorService pool = Executors.newFixedThreadPool(4);
// ... submit tasks ...

pool.shutdown(); // no new tasks
try {
    if (!pool.awaitTermination(30, TimeUnit.SECONDS)) {
        pool.shutdownNow(); // force cancel
    }
} catch (InterruptedException e) {
    pool.shutdownNow();
    Thread.currentThread().interrupt();
}

ExecutorService como AutoCloseable (Java 19+)

A partir de Java 19, ExecutorService implementa AutoCloseable. Use try-with-resources para realizar el apagado automáticamente:

// Java 19+ (preview), Java 21 stable
try (ExecutorService pool = Executors.newFixedThreadPool(4)) {
    pool.submit(() -> System.out.println("task"));
} // pool.close() called: waits for tasks then shuts down

Políticas de rechazo

Cuando el grupo está saturado (todos los hilos están ocupados y la cola está llena), la política de rechazo gestiona el exceso:

AbortPolicy (predeterminada): lanza RejectedExecutionException
CallerRunsPolicy: el hilo que realiza la llamada ejecuta la tarea
DiscardPolicy: descarta la tarea silenciosamente
DiscardOldestPolicy: descarta la tarea más antigua de la cola

Comprobación rápida

Tiene una tarea limitada por la CPU que realiza cálculos intensivos. ¿Cuántos hilos debe tener su grupo de hilos fijo?

Responde en la lección interactiva

Repaso: ExecutorService y grupos de hilos

Conceptos clave:

Grupo fijo: N hilos fijos; las tareas adicionales se ponen en cola
Grupo en caché: crece bajo demanda; los hilos inactivos expiran después de 60 s
Un solo hilo: garantiza el orden de ejecución secuencial
Grupo programado: tareas retrasadas y recurrentes
Llame siempre a shutdown(); use awaitTermination() para una salida ordenada

Gratis para empezar

Aprende Java con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 104
Lecciones: 374

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «ExecutorService y tipos de grupos de hilos» es gratis?

Sí — el texto completo de «ExecutorService y tipos de grupos de hilos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «ExecutorService y tipos de grupos de hilos»?

Cree grupos de hilos fijos, en caché, individuales y programados, y comprenda cuándo usar cada uno. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «ExecutorService y tipos de grupos de hilos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

ExecutorService y tipos de grupos de hilos
Envío de tareas: Runnable frente a Callable
Future y gestión de errores
ScheduledExecutorService para tareas recurrentes

← Volver a Java Academy