En el desarrollo actual con frameworks como Tomcat o Dubbo, los grupos de hilos son esenciales. Una pregunta recurrente es: ¿cuántos hilos configurar? Una configuración arbitraria no solo puede ser ineficaz, sino contraproducente. Este análisis profundiza en la ciencia y mejores prácticas detrás de los parámetros de ThreadPoolExecutor.

El caso para los grupos de hilos

Crear un Thread directamente en Java implica operaciones de sistema costosas. La creación y destrucción frecuente de hilos es ineficiente. La solución es la "pulimentación" mediante grupos de hilos (thread pools), cuya implementación estándar en JDK es ThreadPoolExecutor.

Los beneficios incluyen:

• Reducción de sobrecarga: Reutiliza hilos existentes.
• Mejora de velocidad de respuesta: Las tareas se ejecutan inmediatamente si hay hilos disponibles.
• Gestión centralizada: Permite control, supervisión y ajuste de un recurso escaso.
• Funcionalidades extendidas: Clases como ScheduledThreadPoolExecutor ofrecen ejecución diferida o periódica.

Arquitectura y diseño de ThreadPoolExecutor

El marco de trabajo sigue un modelo jerárquico: Executor (interfaz simple), ExecutorService (extiende capacidades con submit() y shutdown()), AbstractExecutorService (abstracción del flujo), y las implementaciones concretas ThreadPoolExecutor y ScheduledThreadPoolExecutor. La clase Executors proporciona métodos de fábrica.

Parámetros del constructor

La configuración se realiza a través de siete parámetros clave:

ThreadPoolExecutor(
  int corePoolSize,
  int maximumPoolSize,
  long keepAliveTime,
  TimeUnit unit,
  BlockingQueue<Runnable> workQueue,
  ThreadFactory threadFactory,
  RejectedExecutionHandler handler)

• corePoolSize: Número base de hilos. Se mantienen vivos incluso inactivos.
• maximumPoolSize: Límite máximo de hilos (core + no-core).
• keepAliveTime y unit: Tiempo que un hilo no-core (o core si se permite) puede estar ocioso antes de ser eliminado.
• workQueue: Cola de tareas pendientes. Su elección impacta directamente en el rendimiento y manejo de carga.
• threadFactory: Para personalizar la creación de hilos (nombre, prioridad, daemon).
• handler: Estrategia de rechazo cuando el grupo y la cola están llenos. Las estrategias por defecto son:
  • CallerRunsPolicy: El hilo llamante ejecuta la tarea.
  • AbortPolicy (default): Lanza RejectedExecutionException.
  • DiscardPolicy: Desscarta silenciosamente la tarea.
  • DiscardOldestPolicy: Descarta la tarea más antigua en la cola y reintenta.

Flujo de ejecución

El método execute(Runnable) define la lógica central:

public void execute(Runnable command) {
    if (command == null) throw new NullPointerException();
    int estado = ctl.get();
    // 1. Intentar asignar a un hilo core
    if (contadorHilos(estado) < corePoolSize) {
        if (agregarTrabajador(command, true)) return;
        estado = ctl.get();
    }
    // 2. Encolar la tarea si el pool está activo
    if (enEjecucion(estado) && colaTrabajo.offer(command)) {
        int recheck = ctl.get();
        if (!enEjecucion(recheck) && eliminar(command))
            rechazar(command);
        else if (contadorHilos(recheck) == 0)
            agregarTrabajador(null, false);
    }
    // 3. Intentar crear un hilo no-core
    else if (!agregarTrabajador(command, false))
        rechazar(command); // 4. Aplicar estrategia de rechazo
}

El flujo es: 1) Asignar a hilo core si hay espacio. 2) Encolar si el pool está corriendo. 3) Crear hilo no-core si se puede. 4) Rechazar si nada es posible.

Estados del grupo de hilos

El estado (runState) y el conteo de hilos (workerCount) se empaquetan en un solo entero AtomicInteger (ctl) para garantizar consistencia atómica. Los estados definidos son: RUNNING, SHUTDOWN, STOP, TIDYING y TERMINATED.

Cola de trabajo (BlockingQueue)

Desacopla productores (quienes envían tareas) y consumidores (hilos trabajadores). Su elección es crítica:

• ArrayBlockingQueue: Bounded, basada en array.
• LinkedBlockingQueue: Por defecto no bounded (Integer.MAX_VALUE), puede causar OOM.
• SynchronousQueue: Sin capacidad, cada put espera un take.
• PriorityBlockingQueue: Ordena tareas por prioridad.

El rol de los Trabajadores (Worker)

Un Worker es tanto un Runnable que encapsula la ejecución de tareas, como un contenedor para un hilo. Extiende AQS para un bloqueo no reentrante que refleja su estado de ejecución.

private final class Trabajador extends AbstractQueuedSynchronizer implements Runnable {
    final Thread hilo;
    Runnable tareaInicial;

    Trabajador(Runnable tarea) {
        setState(-1); // Prevenir interrupciones hasta run()
        this.tareaInicial = tarea;
        this.hilo = getFabricaHilos().newThread(this);
    }
    public void run() { ejecutarTrabajador(this); }
    // ... métodos AQS
}

Los trabajadores se gestionan en un Set<Worker>. Su ciclo de vida implica la adición mediante addWorker, la obtención de tareas con getTask (que bloquea o espera según el tipo de hilo), la ejecución en runWorker, y finalmente su remoción y posible reemplazo en processWorkerExit.

Prácticas recomendadas y configuración

Evitar la fábrica Executors

Los métodos como newFixedThreadPool() usan LinkedBlockingQueue sin límite, arriesgando OutOfMemoryError. Se recomienda crear ThreadPoolExecutor explícitamente con una cola acotada (ArrayBlockingQueue), lo que fuerza a considerar una estrategia de rechazo adecuada.

Manejo de excepciones

Las excepciones no controladas en una tarea matan al hilo trabajador sin notificación explícita. Es fundamental envolver la lógica de la tarea en bloques try-catch para manejar errores y evitar la pérdida silenciosa de trabajadores.

Cómo dimensionar el grupo

La configuración ideal depende de la naturaleza de las tareas:

• Tareas intensivas en CPU: Un número cercano a los núcleos de CPU (N), ej. N + 1.
• Tareas intensivas en I/O: Se benefician de más hilos, ya que pasan mucho tiempo esperando, ej. 2 * N o superior.
• Tareas mixtas: Considerar separar en diferentes grupos de hilos si sus características son muy dispares.

El uso de colas acotadas es fundamental para la estabilidad. Monitorizar métricas como el tamaño de la cola y la tasa de rechazo es crucial para ajustar estos parámetros en producción.