Ideal Pool Size

¿Cómo encontrar el tamaño ideal del pool de hilos?

Como en muchas decisiones de informática, la respuesta es: depende. Sin embargo, vale la pena analizarlo.

Imagina que tienes una tarea intensiva en CPU, es decir, que consume la mayor parte de su tiempo realizando cálculos sin depender de operaciones de E/S. En Java, cada hilo corresponde a un hilo del sistema operativo (native thread), y dado que la CPU tiene un número limitado de núcleos, solo puede ejecutar simultáneamente tantas tareas como núcleos tenga disponibles.

Por ejemplo, si tu CPU tiene 4 núcleos, el máximo número de tareas que puedes ejecutar en paralelo sin sobrecarga adicional es 4. Crear un número excesivo de hilos no solo es inútil en este caso, sino que puede degradar el rendimiento en lugar de mejorarlo.

¿Por qué demasiados hilos pueden reducir el rendimiento?

Si creas, por ejemplo, 100 hilos para ejecutar tareas intensivas en CPU en una máquina con solo 4 núcleos, todos estos hilos competirán por el tiempo de procesamiento. Esto genera un problema conocido como context switching (cambio de contexto).

Cuando hay más hilos que núcleos disponibles, el sistema operativo debe pausar y reanudar hilos constantemente para repartir el tiempo de CPU entre ellos. Este cambio de contexto implica:

1. Guardar el estado del hilo actual.
2. Cargar el estado del siguiente hilo que va a ejecutarse.
3. Restaurar el contexto de ejecución.

Este proceso tiene un costo en términos de rendimiento. Si el número de hilos supera cierto umbral, el tiempo invertido en cambios de contexto puede superar el beneficio de usar múltiples hilos, haciendo que la aplicación corra más lenta en lugar de más rápido.

¿Cuál es el número ideal de hilos en este caso?

Tareas intensivas en CPU

Para tareas intensivas en CPU, una regla común es establecer el tamaño del thread pool cercano al número de núcleos disponibles en la CPU. En términos generales:

Número óptimo de hilos ≈ Núcleos de la CPU+1

El “+1” se puede agregar para manejar pequeños retardos en la ejecución. Sin embargo, si hay hyper-threading, el número óptimo podría ser mayor, pero nunca excesivo.

Para tareas que consumen muchos recursos de CPU, lo ideal es crear un número de hilos igual al número de núcleos disponibles en el procesador. Sin embargo, es importante recordar que el sistema operativo también ejecuta otros procesos, por lo que no podemos asumir que todos los núcleos estarán dedicados exclusivamente a nuestros hilos.

Ejemplo de código en Java

Podemos usar el paquete ExecutorService para administrar nuestros hilos de manera eficiente. A continuación, se muestra un ejemplo de una tarea intensiva en CPU que se ejecuta con un pool de hilos fijos:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class CPUTask implements Runnable {
    @Override
    public void run() {
        System.out.println("Ejecutando tarea intensiva en CPU en el hilo: " + Thread.currentThread().getName());
        // Simulación de trabajo intensivo en CPU
        for (int i = 0; i < 1_000_000; i++) Math.sqrt(i);
    }
}

public class ThreadPoolExample {
    public static void main(String[] args) {
        // Obtener el número de núcleos disponibles
        int numCores = Runtime.getRuntime().availableProcessors();
        System.out.println("Número de núcleos disponibles: " + numCores);

        // Crear un pool de hilos con el mismo número de núcleos
        ExecutorService executor = Executors.newFixedThreadPool(numCores);
        System.out.println("Grupo de subprocesos creado con " + numCores + " hilos.");

        // Ejecutar 20 tareas en el pool de hilos
        for (int i = 0; i < 20; i++) {
            executor.execute(new CPUTask());
        }

        // Cerrar el ejecutor después de ejecutar las tareas
        executor.shutdown();
    }
}

Salida esperada

Si ejecutamos este programa en una máquina con 14 núcleos, veremos una salida similar a esta:

Número de núcleos disponibles: 14
Grupo de subprocesos creado con 14 hilos.
Ejecutando tarea intensiva en CPU en el hilo: pool-1-thread-1
Ejecutando tarea intensiva en CPU en el hilo: pool-1-thread-2
Ejecutando tarea intensiva en CPU en el hilo: pool-1-thread-3
...

Como podemos observar, el pool de hilos tiene exactamente 14 hilos (uno por núcleo) y estos se reutilizan para ejecutar las 20 tareas en cola.

---

Tareas intensivas en E/S (I/O-bound)

En contraste con las tareas intensivas en CPU, las tareas que dependen de operaciones de entrada/salida (I/O-bound) tienen un comportamiento diferente.

Ejemplos de tareas I/O-bound incluyen:

• Leer o escribir archivos en disco
• Consultar bases de datos
• Realizar llamadas a servicios web

Estas tareas no mantienen ocupada la CPU en todo momento, ya que pasan gran parte del tiempo esperando la respuesta de un recurso externo. Por esta razón, tener más hilos en el pool permite que otras tareas se ejecuten mientras algunos hilos están inactivos esperando.

¿Cuántos hilos usar para tareas I/O-bound?

A diferencia de las tareas intensivas en CPU, aquí podemos usar más hilos que núcleos, y una fórmula comúnmente utilizada es:

Nuˊmero de hilos=Nuˊcleos de CPU×(1+Tiempo de espera/Tiempo de CPU)\text{Número de hilos} = \text{Núcleos de CPU} \times (1 + \text{Tiempo de espera} / \text{Tiempo de CPU})

Nuˊmero de hilos=Nuˊcleos de CPU×(1+Tiempo de espera/Tiempo de CPU)

En la práctica, esto significa que podemos experimentar con un mayor número de hilos en el pool hasta encontrar un equilibrio óptimo entre concurrencia y utilización de recursos.

---

Conclusión

No hay una respuesta única al número ideal de hilos en un pool. La estrategia óptima depende del tipo de tarea que ejecutemos:

• Para tareas intensivas en CPU, el número de hilos debería estar cerca del número de núcleos disponibles.
• Para tareas intensivas en I/O, podemos usar más hilos de los que hay núcleos, ya que muchos pasarán tiempo esperando respuestas externas.

Lo más recomendable es analizar el comportamiento de nuestra aplicación y ajustar el tamaño del pool de hilos en función de pruebas y mediciones del rendimiento.