ThreadPoolExecutor

"Los programadores comunes, tarde o temprano, se dan cuenta del hecho de que tienen muchas tareas pequeñas que deben realizarse de vez en cuando".

"Si estás escribiendo un juego, entonces son las acciones que realizan los personajes individuales".

"Si está escribiendo un servidor web, los usuarios reciben diferentes comandos: cargue una foto, transcodifique al formato deseado, aplique la plantilla deseada, etc."

"Tarde o temprano, todas las grandes tareas se dividen en un conjunto de tareas pequeñas y manejables".

"Entonces, dado este contexto, surge una pregunta sutil: ¿cómo se supone que debe administrarlos todos? ¿Qué sucede si necesita realizar varios cientos de tareas en un minuto? Crear un hilo para cada tarea no tendría mucho sentido. La máquina Java asigna una gran cantidad de recursos para cada subproceso".

"En otras palabras, crear y destruir un hilo puede llevar más tiempo y recursos que la tarea misma".

"A los creadores de Java se les ocurrió una solución elegante a este problema: ThreadPoolExecutor .

" ThreadPoolExecutor es una clase con dos cosas dentro:"

A)  Una cola de tareas, a la que puede agregar tareas a medida que surjan en el programa.

B) Un grupo de subprocesos, que es un grupo de subprocesos que realizan estas tareas.

"Además, los hilos no se destruyen una vez que finaliza una tarea. En cambio, se quedan dormidos para estar listos para comenzar una nueva tarea tan pronto como aparezca".

"Cuando crea un ThreadPoolExecutor , puede establecer la cantidad máxima de subprocesos que se crearán y la cantidad máxima de tareas que se pueden poner en cola. En otras palabras, puede limitar la cantidad de subprocesos a 10, por ejemplo, y la cantidad de tareas en cola a 100".

"Así es como funciona ThreadPoolExecutor :"

1)  Cuando agrega una nueva tarea, se coloca al final de la cola.

2)  Si la cola está llena, se lanza una excepción.

3)  Al completar una tarea, cada subproceso toma la siguiente tarea de la cola y comienza a ejecutarla.

4) Si no hay tareas en la cola, un subproceso se duerme hasta que se agregan nuevas tareas.

"El enfoque, en el que limitamos la cantidad de subprocesos de trabajo, es ventajoso porque cuantos más subprocesos tenemos, más interfieren entre sí. Es mucho más efectivo tener de 5 a 10 subprocesos de trabajo y una larga cola de tareas que para crear 100 subprocesos para una oleada de tareas, que competirán entre sí por los recursos: memoria, tiempo de procesador, acceso a la base de datos, etc.

"Aquí hay un ejemplo de ThreadPoolExecutor en acción:"

ExecutorService service = Executors.newFixedThreadPool(2);

for(int i = 0; i < 10; i++)
{
 service.submit(new Runnable() {
    public void run()
    {
     // Here we download something big from the Internet.
    }
 });
}

"Eh, no lo veo..."

" Se crea un objeto ThreadPoolExecutor cuando se llama al método newFixedThreadPool".

Por lo tanto, es muy fácil de usar. Tan pronto como le agregue una tarea con el método de envío, esta:

A)  Despierta un subproceso inactivo, si lo hay, para ejecutar la tarea.

B)  Si no hay un hilo en espera, crea uno nuevo para la tarea.

C)  Si se alcanza el número máximo de subprocesos, simplemente coloca la tarea al final de la cola.

"Deliberadamente incluí 'aquí descargamos algo grande de Internet' en el ejemplo. Si tenemos 100 tareas 'descargamos algo grande de Internet', entonces no tiene sentido ejecutar muchas de ellas al mismo tiempo. Será retenido por el límite de ancho de banda de nuestra conexión a Internet. En este caso, un par de subprocesos deberían ser suficientes. Esto es lo que ve en el ejemplo anterior:"

ExecutorService service = Executors.newFixedThreadPool(2);

"Resulta que trabajar con un montón de tareas no es tan difícil".

"Sí. Incluso más fácil de lo que te imaginas. Pero Kim te lo contará".