Multitarea e Hilos en Java

Multitarea e Hilos en Java con ejemplos (Thread & Runnable)

En esta entrada vamos a ver las diferentes maneras de como trabajar con Threads en Java (o hilos en español). Sino tienes muy claro el concepto de la multitarea te recomendamos que te leas primero la entrada de Multitaréa e Hilos, fácil y muchas ventajas aunque en esta entrada también veremos (en menor detalle) los conceptos y las ventajas de la multitarea.

En esencia la multitarea nos permite ejecutar varios procesos a la vez; es decir, de forma concurrente y por tanto eso nos permite hacer programas que se ejecuten en menor tiempo y sean más eficientes. Evidentemente no podemos ejecutar infinitos procesos de forma concurrente ya que el hardware tiene sus limitaciones, pero raro es a día de hoy los ordenadores que no tengan más de un núcleo por tanto en un procesador con dos núcleos se podrían ejecutar dos procesos a la vez y así nuestro programa utilizaría al máximo los recursos hardware. Para que veáis la diferencia en un par de imágenes, supongamos que tenemos un programa secuencial en el que se han de ejecutar 4 procesos; uno detrás de otro, y estos tardan unos segundos:

Si en vez de hacerlo de forma secuencial, lo hiciésemos con 4 hilos, el programa tardaría en ejecutarse solo 20 segundos, es decir el tiempo que tardaría en ejecutarse el proceso más largo. Esto evidentemente sería lo ideal, pero la realidad es que no todo se puede paralelizar y hay que saber el número de procesos en paralelo que podemos lanzar de forma eficiente. En principio en esta entrada no vamos a hablar sobre ello ya que el objetivo de la misma es ver como se utilizan los hilos en java con un ejemplo relativamente sencillo y didáctico.

En Java para utilizar la multitarea debemos de usar la clase Thread (es decir que la clase que implementemos debe heredar de la clase Thread) y la clase Thread implementa laInterface Runnable. En el siguiente diagrama de clase mostramos la Interface Runnable y la clase Thread con sus principales métodos:

En esta entrada no vamos a ver como utilizar todos los métodos de la clase Thread, pero os los mostramos para que sepáis que existen y a parte por su nombre podéis intuir su funcionalidad.

En esta entrada vamos a poner un ejemplo para que veáis las ventajas de la multitarea, viendo como se ejecutaría un programa sin utilizar la multitarea y otro utilizándola.

En este ejemplo vamos a simular el proceso de cobro de un supermercado; es decir, unos clientes van con un carro lleno de productos y una cajera les cobra los productos, pasándolos uno a uno por el escaner de la caja registradora. En este caso la cajera debe de procesar la compra cliente a cliente, es decir que primero le cobra al cliente 1, luego al cliente 2 y así sucesivamente. Para ello vamos a definir una clase “Cajera” y una clase “Cliente” el cual tendrá un “array de enteros” que representaran los productos que ha comprado y el tiempo que la cajera tardará en pasar el producto por el escaner; es decir, que si tenemos un array con [1,3,5] significará que el cliente ha comprado 3 productos y que la cajera tardara en procesar el producto 1 ‘1 segundo’, el producto 2 ‘3 segundos’ y el producto 3 en ‘5 segundos’, con lo cual tardara en cobrar al cliente toda su compra ‘9 segundos’.

Explicado este ejemplo vamos a ver como hemos definido estas clases:

Clase “Cajera.java“:

public class Cajera {  private String nombre;  // Constructor, getter y setter  public void procesarCompra(Cliente cliente, long timeStamp) {  System.out.println("La cajera " + this.nombre +  " COMIENZA A PROCESAR LA COMPRA DEL CLIENTE " + cliente.getNombre() +  " EN EL TIEMPO: " + (System.currentTimeMillis() - timeStamp) / 1000 + "seg");  for (int i = 0; i < cliente.getCarroCompra().length; i++) {  this.esperarXsegundos(cliente.getCarroCompra()[i]);  System.out.println("Procesado el producto " + (i + 1) +   " ->Tiempo: " + (System.currentTimeMillis() - timeStamp) / 1000 +  "seg"); }  System.out.println("La cajera " + this.nombre + " HA TERMINADO DE PROCESAR " +  cliente.getNombre() + " EN EL TIEMPO: " +  (System.currentTimeMillis() - timeStamp) / 1000 + "seg");  }   private void esperarXsegundos(int segundos) { try { Thread.sleep(segundos * 1000); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); } }}

Clase “Cliente.java“:

public class Cliente {  private String nombre; private int[] carroCompra;  // Constructor, getter y setter}

Si ejecutásemos este programa propuesto con dos Clientes y con un solo proceso (que es lo que se suele hacer normalmente), se procesaría primero la compra del Cliente 1 y después la del Cliente 2, con lo cual se tardará el tiempo del Cliente 1 + Cliente 2. A continuación vamos a ver como programamos el método Main para lanzar el programa.CUIDADO: Aunque hayamos puesto dos objetos de la clase Cajera (cajera1 y cajera2) no significa que tengamos dos cajeras independientes, lo que estamos diciendo es que dentro del mismo hilo se ejecute primero los métodos de la cajera1 y después los métodos de la cajera2, por tanto a nivel de procesamiento es como si tuviésemos una sola cajera:

Clase “Main.java“:

public class Main {  public static void main(String[] args) {  Cliente cliente1 = new Cliente("Cliente 1", new int[] { 2, 2, 1, 5, 2, 3 }); Cliente cliente2 = new Cliente("Cliente 2", new int[] { 1, 3, 5, 1, 1 });  Cajera cajera1 = new Cajera("Cajera 1"); Cajera cajera2 = new Cajera("Cajera 2");  // Tiempo inicial de referencia long initialTime = System.currentTimeMillis();  cajera1.procesarCompra(cliente1, initialTime); cajera2.procesarCompra(cliente2, initialTime); }}

Si ejecutamos este código tendremos lo siguiente:

La cajera Cajera 1 COMIENZA A PROCESAR LA COMPRA DEL CLIENTE Cliente 1 EN EL TIEMPO: 0seg Procesado el producto 1 ->Tiempo: 2seg Procesado el producto 2 ->Tiempo: 4seg Procesado el producto 3 ->Tiempo: 5seg Procesado el producto 4 ->Tiempo: 10seg Procesado el producto 5 ->Tiempo: 12seg Procesado el producto 6 ->Tiempo: 15seg La cajera Cajera 1 HA TERMINADO DE PROCESAR Cliente 1 EN EL TIEMPO: 15seg La cajera Cajera 2 COMIENZA A PROCESAR LA COMPRA DEL CLIENTE Cliente 2 EN EL TIEMPO: 15seg Procesado el producto 1 ->Tiempo: 16seg Procesado el producto 2 ->Tiempo: 19seg Procesado el producto 3 ->Tiempo: 24seg Procesado el producto 4 ->Tiempo: 25seg Procesado el producto 5 ->Tiempo: 26seg La cajera Cajera 2 HA TERMINADO DE PROCESAR Cliente 2 EN EL TIEMPO: 26seg

Como vemos se procesa primero la compra del cliente 1 y después la compra del cliente 2 tardando en procesar ambas compras un tiempo de 26 segundos.

¿Y si en vez de procesar primero un cliente y después otro, procesásemos los dos a la vez?, ¿Cuanto tardaría el programa en ejecutarse?. Pues bien si en vez de haber solo una Cajera (es decir un solo hilo), hubiese dos Cajeras (es decir dos hilos o threads) podríamos procesar los dos clientes a la vez y tardar menos tiempo en ejecutarse el programa. Para ello debemos de modificar la clase “Cajera.java” y hacer que esta clase herede de la clase Thread para heredar y sobre-escribir algunos de sus métodos. Primero vamos a ver como codificamos esta nueva clase “CajeraThread.java” y después explicamos sus caracteristicas.

public class CajeraThread extends Thread {  private String nombre;  private Cliente cliente;  private long initialTime;  // Constructor, getter & setter  @Override public void run() {  System.out.println("La cajera " + this.nombre + " COMIENZA A PROCESAR LA COMPRA DEL CLIENTE "  + this.cliente.getNombre() + " EN EL TIEMPO: "  + (System.currentTimeMillis() - this.initialTime) / 1000  + "seg");  for (int i = 0; i < this.cliente.getCarroCompra().length; i++) {  this.esperarXsegundos(cliente.getCarroCompra()[i]);  System.out.println("Procesado el producto " + (i + 1)  + " del cliente " + this.cliente.getNombre() + "->Tiempo: "  + (System.currentTimeMillis() - this.initialTime) / 1000  + "seg"); }  System.out.println("La cajera " + this.nombre + " HA TERMINADO DE PROCESAR "  + this.cliente.getNombre() + " EN EL TIEMPO: "  + (System.currentTimeMillis() - this.initialTime) / 1000  + "seg"); }  private void esperarXsegundos(int segundos) { try { Thread.sleep(segundos * 1000); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); } }}

Lo primero que vemos y que ya hemos comentado es que la clase “CajeraThread” debe de heredar de la clase Thread: “extendsThread“.

Otra cosa importante que vemos es que hemos sobre-escrito el método  “run()” (de ahi la etiqueta @Override) . Este método es imprescindibles sobre-escribirlo (ya que es un método que esta en la clase Runnable y la clase Thread Implementa esa Interface) porque en él se va a codificar la funcionalidad que se ha de ejecutar en un hilo; es decir, que lo que se programe en el método “run()” se va a ejecutar de forma secuencial en un hilo. En esta clase “CajeraThread” se pueden sobre-escribir más métodos para que hagan acciones sobre el hilo o thread como por ejemplo, parar el thread, ponerlo en reposos, etc. A continuación vamos a ver como programamos el método Main para que procese a los clientes de forma paralela y ver como se tarda menos en procesar todo. El método Main esta en la clase “MainThread.java” que tiene el siguiente contenido:

public class MainThread {  public static void main(String[] args) {  Cliente cliente1 = new Cliente("Cliente 1", new int[] { 2, 2, 1, 5, 2, 3 }); Cliente cliente2 = new Cliente("Cliente 2", new int[] { 1, 3, 5, 1, 1 });  // Tiempo inicial de referencia long initialTime = System.currentTimeMillis(); CajeraThread cajera1 = new CajeraThread("Cajera 1", cliente1, initialTime); CajeraThread cajera2 = new CajeraThread("Cajera 2", cliente2, initialTime);  cajera1.start(); cajera2.start(); }}

Ahora vamos a ver cual sería el resultado de esta ejecución y vamos a comprobar como efectivamente el programa se ejecuta de forma paralela y tarda solo 15 segundos en terminar su ejecución:

La cajera Cajera 1 COMIENZA A PROCESAR LA COMPRA DEL CLIENTE Cliente 1 EN EL TIEMPO: 0seg La cajera Cajera 2 COMIENZA A PROCESAR LA COMPRA DEL CLIENTE Cliente 2 EN EL TIEMPO: 0seg Procesado el producto 1 del cliente Cliente 2->Tiempo: 1seg Procesado el producto 1 del cliente Cliente 1->Tiempo: 2seg Procesado el producto 2 del cliente Cliente 2->Tiempo: 4seg Procesado el producto 2 del cliente Cliente 1->Tiempo: 4seg Procesado el producto 3 del cliente Cliente 1->Tiempo: 5seg Procesado el producto 3 del cliente Cliente 2->Tiempo: 9seg Procesado el producto 4 del cliente Cliente 2->Tiempo: 10seg Procesado el producto 4 del cliente Cliente 1->Tiempo: 10seg Procesado el producto 5 del cliente Cliente 2->Tiempo: 11seg La cajera Cajera 2 HA TERMINADO DE PROCESAR Cliente 2 EN EL TIEMPO: 11seg Procesado el producto 5 del cliente Cliente 1->Tiempo: 12seg Procesado el producto 6 del cliente Cliente 1->Tiempo: 15seg La cajera Cajera 1 HA TERMINADO DE PROCESAR Cliente 1 EN EL TIEMPO: 15seg 

En este ejemplo vemos como el efecto es como si dos cajeras procesasen la compra de los clientes de forma paralela sin que el resultado de la aplicación sufra ninguna variación en su resultado final, que es el de procesar todas las compras de los clientes de forma independiente. De forma gráfica vemos que el programa ha realizado lo siguiente en dos hilos distintos:

Otra forma de hacer lo mismo pero sin heredar de la clase “Thread” es implementar la Interface “Runnable”. En este caso no dispondremos ni podremos sobre-escribir los métodos de la clase Thread ya que no la vamos a utilizar y solo vamos a tener que sobre-escribir el método “run()“. En este caso solo será necesario implementar el método “run()” para que los procesos implementados en ese método se ejecuten en un hilo diferente. Vamos a ver un ejemplo de como utilizando objetos de las clases “Cliente.java” y “Cajera.java” podemos implementar la multitarea en la misma clase donde se llama al método Main de la aplicación. A continuación vemos la codificación en la clase “MainRunnable.java“:

public class MainRunnable implements Runnable{ private Cliente cliente; private Cajera cajera; private long initialTime; public MainRunnable (Cliente cliente, Cajera cajera, long initialTime){ this.cajera = cajera; this.cliente = cliente; this.initialTime = initialTime; }  public static void main(String[] args) { Cliente cliente1 = new Cliente("Cliente 1", new int[] { 2, 2, 1, 5, 2, 3 }); Cliente cliente2 = new Cliente("Cliente 2", new int[] { 1, 3, 5, 1, 1 }); Cajera cajera1 = new Cajera("Cajera 1"); Cajera cajera2 = new Cajera("Cajera 2"); // Tiempo inicial de referencia long initialTime = System.currentTimeMillis(); Runnable proceso1 = new MainRunnable(cliente1, cajera1, initialTime); Runnable proceso2 = new MainRunnable(cliente2, cajera2, initialTime); new Thread(proceso1).start(); new Thread(proceso2).start();  }  @Override public void run() { this.cajera.procesarCompra(this.cliente, this.initialTime); }}

En este caso implementamos el método “run()” dentro de la misma clase donde se encuentra el método Main, y en el llamamos al método de “procesarCompra()” de la clase Cajera. Dentro del método Main, nos creamos dos objetos de la misma clase en la que estamos (“new MainRunnable”) y nos creamos dos objetos de la clase Thread para lanzar los proceso y que se ejecuten estos en paralelo. El resultado de esta ejecución es el mismo que en el caso anterior:

La cajera Cajera 2 COMIENZA A PROCESAR LA COMPRA DEL CLIENTE Cliente 2 EN EL TIEMPO: 0seg La cajera Cajera 1 COMIENZA A PROCESAR LA COMPRA DEL CLIENTE Cliente 1 EN EL TIEMPO: 0seg Procesado el producto 1 del cliente Cliente 2->Tiempo: 1seg Procesado el producto 1 del cliente Cliente 1->Tiempo: 2seg Procesado el producto 2 del cliente Cliente 2->Tiempo: 4seg Procesado el producto 2 del cliente Cliente 1->Tiempo: 4seg Procesado el producto 3 del cliente Cliente 1->Tiempo: 5seg Procesado el producto 3 del cliente Cliente 2->Tiempo: 9seg Procesado el producto 4 del cliente Cliente 2->Tiempo: 10seg Procesado el producto 4 del cliente Cliente 1->Tiempo: 10seg Procesado el producto 5 del cliente Cliente 2->Tiempo: 11seg La cajera Cajera 2 HA TERMINADO DE PROCESAR Cliente 2 EN EL TIEMPO: 11seg Procesado el producto 5 del cliente Cliente 1->Tiempo: 12seg Procesado el producto 6 del cliente Cliente 1->Tiempo: 15seg La cajera Cajera 1 HA TERMINADO DE PROCESAR Cliente 1 EN EL TIEMPO: 15seg

CONCLUSIONES Y ACLARACIONES:

El concepto de multitarea o multiprocesamiento es bastante sencillo de entender ya que solo consiste en hacer varias cosas a la vez sin que se vea alterado el resultado final. Como ya se ha dicho en la entrada no todo se puede paralelizar y en muchas ocasiones suele ser complicado encontrar la manera de paralelizar procesos dentro de una aplicación sin que esta afecte al resultado de la misma, por tanto aunque el concepto sea fácil de entender el aplicarlo a un caso práctico puede ser complicado para que el resultado de la aplicación no se vea afectado.

Por otro lado para los que empecéis a ver estos temas de la concurrencia, multitarea y demás, no so preocupéis al principio si os cuesta programar problemas de este tipo ya que a parte de la multitarea se mezclan cosas como la herencia y las Interfaces que al principio son cosas que cuestan de asimilar, así que ir poco a poco pero tener muy claro que la multitarea es muy util y se ha de aplicar para hacer las aplicaciones más eficientes y que den mejor rendimiento.

El proyecto de este post lo puedes descargar pulsando AQUI.