Java / Comunicacion InterThread

Bienvenidos sean a este post, hoy hablaremos sobre la llamada comunicacion interthread o comunicacion entre procesos la cual es utilizada cuando tenemos un programa que tiene dos o mas procesos y entre ellos se intercambian informacion, veamos tres metodos disponibles que nos facilitan la comunicacion entre procesos:

• public void wait(), ocasiona que el proceso actual espere hasta que otro proceso invoque al notify()
• public void notify(), reanuda a un solo proceso que esta esperando al monitor del objeto
• public void notifyAll(), reanuda todos los procesos que llamaron a wait() en el mismo objeto

Estos metodos son implementados como tipo final en un objeto, por lo tanto estan disponibles en todo tipo de clases y estos metodos solo pueden ser llamados dentro del contexto de un bloque sincronizado (synchronized), para entenderlo un poco mejor veamos el siguiente ejemplo donde implementaremos a wait() y notify():

ProcesoPrueba.java

class Chat
{
        boolean flag = false;

        public synchronized void Pregunta(String msn)
        {
                if (flag)
                {
                        try
                        {
                          wait();
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }
                }
                System.out.println(msn);
                flag = true;
                notify();
        }

        public synchronized void Respuesta(String msn)
        {
                if (!flag)
                {
                        try
                        {
                          wait();
                        }
                        catch (InterruptedException e)
                        {
                                e.printStackTrace();
                        }
                }
                System.out.println(msn);
                flag = false;
                notify();
        }
}

class T1 implements Runnable
{
        Chat m;
        String[] s1 = { "Holis","Como estas?","Yo tambien estoy bien!" };

        public T1(Chat m1)
        {
                this.m = m1;
                new Thread(this, "Pregunta").start();
        }

        public void run()
        {
                for(int i = 0; i < s1.length; i++)
                        m.Pregunta(s1[i]);
        }
}

class T2 implements Runnable
{
        Chat m;
        String[] s2 = { "Hola","Estoy bien, y tu como estas?","Buenisimo!" };

        public T2(Chat m2)
        {
                this.m = m2;
                new Thread(this, "Respuesta").start();
        }

        public void run()
        {
                for(int i = 0; i < s2.length; i++)
                        m.Respuesta(s2[i]);
        }
}

public class ProcesoPrueba
{
        public static void main(String[] args)
        {
                Chat m = new Chat();
                new T1(m);
                new T2(m);
        }
}

Para este ejemplo veremos nuestra primera clase llamada Chat, primero crearemos una variable llamada flag de tipo boolean y le asignaremos un valor false, en esta clase luego tendremos un metodo llamado Pregunta de tipo synchronized, el cual tendra un bloque try/catch donde llamara a wait() y en caso de error mostrara un mensaje del stack, en este caso sino ocurre nada mostrara el mensaje informado, pasara la variable flag a true y luego llamara a notify(), nuestro siguiente metodo llamado Respuesta tambien de tipo synchronized hace exactamente lo mismo pero la diferencia esta en el bloque if donde en lugar de esperar un flag de tipo true esperara un flag de valor false, esto por medio del negador (!) y seteamos la variable flag en estado false el respuesta hace exactamente lo mismo.

Nuestra siguiente clase se llama T1 donde implementaremos a la clase Runnable, primero crearemos una variable de tipo Chat llamada m, luego un array de tipo String donde ingresaremos tres textos y llamaremos s1, despues implementaremos un constructor donde recibira un atributo de tipo Chat, este atributo sera asignado a la variable m de nuestra clase y despues crearemos un nuevo Thread (proceso) llamado Pregunta y lo iniciaremos, nuestro siguiente metodo se llama run() donde tendra un bucle for que tomara como limite el tamaño del array creado llamado s1, y por medio del objeto m instanciaremos a Pregunta y le enviaremos el texto correspondiente al ordinal de i.

La clase siguiente es T2 que es exactamente igual a la clase anterior pero las unicas diferencias son en el constructor donde llamamos al Thread como Respuesta y en el metodo run() donde llamaremos al metodo Respuesta en lugar de Pregunta del bucle for, en el cuerpo del main simplemente crearemos un objeto de tipo Chat llamado m y luego crearemos dos nuevas llamadas a la clase T1 y T2 donde le enviaremos a m, si lo compilamos y probamos nuestro programa obtendremos esta salida:

tinchicus@dbn001vrt:~/programacion/java/codigo$ java ProcesoPrueba
Holis
Hola
Como estas?
Estoy bien, y tu como estas?
Yo tambien estoy bien!
Buenisimo!
tinchicus@dbn001vrt:~/programacion/java/codigo$

Como pueden ver gracias a synchronized podemos turnar nuestras preguntas y respuestas, observen como primero pregunta T1 y luego responde T2 y luego se ve como se hace correctamente.

En resumen, hoy hemos visto como son las comunicaciones entre procesos, los metodos que podemos usar dentro del bloque sincronizado (synchronized), vimos como implementarlo en un ejemplo, 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.