Java / Multithreading (2° parte)

Bienvenidos sean a este post, hoy continuaremos con nuestro post anterior donde hablamos sobre el MultiThreading (multi proceso) y en ese caso nos centramos en que es un ciclo de vida de un proceso (thread), sus prioridades y sus metodos, en el caso de este post nos centraremos como implementarlos y algunos ejemplos, sin mas preambulos comencemos.

Primero veamos el caso de implementar un thread por medio de una interfaz Runnable, para ello deberemos seguir tres pasos basicos:

1. Se debe implementar run desde una interfaz Runnable, esto creara un punto de entrada para nuestro proceso (thread) y podras volcar toda la logica de negocios dentro de este metodo.
2. Se debe instanciar un Thread por medio de un constructor, veremos uno en el ejemplo
3. Una vez creado este objeto, se puede iniciar con el metodo start la cual llama al metodo run

Veamos un ejemplo para poder implementarlo y entenderlo:

DemoThread.java

class RunnableDemo implements Runnable
{
        private Thread t;
        private String threadNombre;

        RunnableDemo(String nombre)
        {
                threadNombre = nombre;
                System.out.println("Creando " + threadNombre);
        }

        public void run()
        {
                System.out.println("Corriendo " + threadNombre);
                try
                {
                  for(int i = 4; i > 0; i--)
                  {
                        System.out.println("Thread: " + threadNombre
                                                + ", " + i);
                        Thread.sleep(50);
                  }
                }
                catch (InterruptedException e)
                {
                  System.out.println("Thread: " + threadNombre
                                        + " interrumpido.");
                }
                System.out.println("Thread: " + threadNombre + " saliendo.");
        }

        public void start()
        {
                System.out.println("Iniciando " + threadNombre);
                if (t == null)
                {
                        t = new Thread(this, threadNombre);
                        t.start();
                }
        }
}

public class DemoThread
{
        public static void main(String[] args)
        {
                RunnableDemo R1 = new RunnableDemo( "Thread-1" );
                R1.start();
                RunnableDemo R2 = new RunnableDemo( "Thread-2" );
                R2.start();
        }
}

En este caso primero crearemos una clase llamada RunnableDemo la cual implementara a la interfaz Runnable, en la cual tendremos dos variables, luego nuestro constructor para esta clase donde lo utilizaremos para asignar un nombre al Thread, despues definiremos al metodo run() donde mostraremos el nombre del Thread y a su vez usaremos un metodo for para contar cuatro numeros y que acompañen al nombre del Thread para en este caso pausarlo uno 50 milisegundos, tambien usaremos un metodo try/catch para capturar cualquier error y mostrarlo en pantalla, despues mostraremos un mensaje de salida, por ultimo definiremos al metodo start() donde chequearemos si t es igual a null y en caso de ser verdadero creara un nuevo Thread, donde primero informaremos el objeto, en este caso usamos this para decir que es este y luego le pasamos el nombre que asignamos a nuestro proceso Thread, para finalmente iniciarlo por medio de start(), en el cuerpo de nuestra clase solamente crearemos dos objetos de la clase anteriormente definida, RunnableDemo, donde le informaremos el nombre y lo iniciaremos, si lo compilamos y ejecutamos obtendremos la siguiente salida:

tinchicus@dbn001vrt:~/programacion/java/codigo$ java DemoThread
Creando Thread-1
Iniciando Thread-1
Creando Thread-2
Iniciando Thread-2
Corriendo Thread-1
Thread: Thread-1, 4
Corriendo Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread: Thread-1 saliendo.
Thread: Thread-2 saliendo.
tinchicus@dbn001vrt:~/programacion/java/codigo$

Como pueden ver al principio creamos un Thread y luego lo iniciamos, para luego crear otro Thread e iniciarlo, observen como van alternando entre uno y otro para mostrarnos el valor del bucle for en el metodo run() para finalmente mostrarnos la salida, nuestro siguiente tema sera como crear un Thread extendiendo la clase Thread, para realizar esto se deben hacer dos pasos:

1. Necesitas sobreescribir el metodo run() disponible en la clase Thread y al igual que antes nos permite utilizarlo para nuestro programa.
2. Y como en el caso anterior tambien debemos implementar start() para poder usarlo con nuestro objeto creado

En este caso vemos que se nos facilita la posibilidad de implementar los Threads, para entender el concepto veamoslo a traves del siguiente ejemplo:

DemoThread2.java

class ThreadPrueba extends Thread
{
        private Thread t;
        private String threadNombre;

        ThreadPrueba( String nombre )
        {
                threadNombre = nombre;
                System.out.println("Creando " + threadNombre);
        }

        public void run()
        {
                System.out.println("Corriendo " + threadNombre);
                try
                {
                  for(int i = 4; i > 0; i-- )
                  {
                        System.out.println("Thread: " + threadNombre
                                                + ", " + i);
                        Thread.sleep(50);
                  }
                }
                catch (InterruptedException e)
                {
                        System.out.println("Thread " + threadNombre
                                                + " interrumpido.");
                }
                System.out.println("Thread " + threadNombre + " saliendo.");
        }

        public void start()
        {
                System.out.println("Iniciando " + threadNombre);
                if (t == null)
                {
                        t = new Thread(this, threadNombre);
                        t.start();
                }
        }
}

public class DemoThread2
{
        public static void main(String[] args)
        {
                ThreadPrueba T1 = new ThreadPrueba( "Thread-1" );
                T1.start();
                ThreadPrueba T2 = new ThreadPrueba( "Thread-2" );
                T2.start();
        }
}

En este caso trabaja de forma similar al caso anterior pero nuestra mayor diferencia sera que en lugar de implementar una interfaz y tener que definir si o si nuestros metodos run y start extenderemos a la clase Thread y por esto no definiremos sino que sobreescribiremos los metodos run y start que estan disponibles en la clase pero no es obligatorio sino lo hacemos para poder utilizar una funcion mejor definida por nosotros pero en ambos casos todos los metodos y funciones trabajan de la misma forma, si lo compilamos y ejecutamos veremos esta salida:

tinchicus@dbn001vrt:~/programacion/java/codigo$ java DemoThread2
Creando Thread-1
Iniciando Thread-1
Creando Thread-2
Iniciando Thread-2
Corriendo Thread-1
Thread: Thread-1, 4
Corriendo Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 saliendo.
Thread Thread-2 saliendo.
tinchicus@dbn001vrt:~/programacion/java/codigo$

Como pueden ver es exactamente la misma salida y esto significa que podemos utilizar cualquiera de las dos formas y obtendremos la misma utilidad.

En resumen, hoy hemos visto como implementar los Multi Threads para poder tener dos procesos corriendo al mismo tiempo, hemos visto a traves de la implementacion por medio de la interfaz Runnable, otro caso extendiendo la clase Thread, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.

Tengo un Patreon donde podes acceder de manera exclusiva a material para este blog antes de ser publicado, sigue los pasos del link para saber como.