El presente blog no es más que una recopilación de toda la basura que salen del cerebro de un patán. Por su seguridad desconecte todos sus dispositivos electrónicos y permanezca alejado del monitor un mínimo de 42 metros durante su lectura.

No suelo trabajar mucho con hilos. Principalmente por que nunca he necesitado hacer algo complejo a parte de algún pequeño servidor implementando con Sockets en Java. Aún así, el otro día me dio por mirar un poco este tema y de paso aprender alguna cosilla nueva. Y fuí a parar a un interesante articulo que hablaba de las Thread Pools (Piscinas de hilos?) en Java.

Una Thread Pool es basicamente un contenedor dentro del cual se crean y ejecutan hilos. Esto nos permite por ejemplo especificar el número máximo de hilos que se pueden ejecutar en un momento dado, lo cual es muy útil si nos interesa obtener resultados de un hilo rapidamente y no que todos coexistan a la vez.

Otra de los beneficios que obtenemos es que el consumo de memoria será mucho menor ya que al solor permitir la ejecución de un número limitado de hilos, los demás no bloquearán recursos.

Java proporciona dos clases para trabajar con Thread Pools. La primera de ellas es Executors, una clase abstracta con metodos estaticos para crear contenedores de capacidad limitada, contenedores con cache, etc.

La segunda clase es ExecutorService, una interface que hereda de Executor y que nos permitirá trabajar de una manera más fácil y eficaz.

A continuación vamos a ver un ejemplo de uso de estas clases:

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

public class Main {
     public static void main(String args[]) {
          ExecutorService exec = Executors.newFixedThreadPool(5);
          for (int i = 0; i < 100; i++) {
               exec.execute(new Runnable() {
                    public void run() {
                         System.out.println("Running in: " + Thread.currentThread());
                    }
               });
          }

          exec.shutdown();
          try {
               boolean b = exec.awaitTermination(50, TimeUnit.SECONDS);

               System.out.println("All done: " + b);
          } catch (InterruptedException e) {
               e.printStackTrace();
          }
     }
}

Analicemos un poco el código.

La parte más importante es Executors.newFixedThreadPool(5). Con esto estamos definiendo un contenedor de un tamaño máximo de 5 espacios. En estos espacios se insertaran hilos y se ejecutarán. Cuando uno de ellos termine su ejecución, se sacará el hilo de ese espacio y se insertara otro de los que este en la cola.

Más abajo, después de crear 100 hilos y ordenar que se ejecuten, invocamos al método shutdown() de la Thread Pool. Con esta llamada indicamos que, una vez se hayan ejecutado todos los hilos, habremos acabado con nuestro trabajo.

La última parte del código, y para mi la más interesante, es “boolean b = exec.awaitTermination(50, TimeUnit.SECONDS);”. El método awaitTermination detiene la ejecución del programa hasta que haya acabado todo el trabajo o hasta que se sobrepase el número de segundos de espera que se pasan como argumento. En el caso de que el trabajo se finalice en el tiempo especificado, el método devolverá true, indicando que todo ha ido bien. Si se sobrepasa el tiempo, devolverá false, lo que nos indicará que posiblemente tengamos algún problema en la ejecución de algún hilo, ya que la ThreadPool no ha terminado su ejecución en el tiempo esperado.

Bueno, esto es todo por hoy. Espero que haya gustado. Otro día más