comunicación entre subprocesos en java

Question

¿Cómo se comunican en Java los subprocesos que dependen el uno del otro?

Por ejemplo, estoy construyendo un rastreador web con hilos que necesitan datos que provienen de otros hilos.

Answer 1

Eso depende de la naturaleza de la comunicación.

• ¿Es dúplex (es decir, A habla con B y B habla con A)?
• ¿Es la comunicación de datos o comunicación de finalización?
• y así sucesivamente.

La forma más simple y más recomendable de comunicación entre hilos es simplemente esperar la finalización de otros hilos. Eso se hace más fácilmente mediante el uso de Future:

ExecutorService exec = Executors.newFixedThreadPool(50); 
final Future f = exec.submit(task1); 
exec.submit(new Runnable() { 
    @Override 
    public void run() { 
     f.get(); 
     // do stuff 
    } 
}); 

La segunda tarea no se ejecutará hasta que se complete la primera.

Java 5+ tiene muchas utilidades concurrentes para hacer frente a este tipo de cosas. Esto podría significar el uso de LinkedBlockingQueue s, CountDownLatch o muchos, muchos otros.

Para un examen en profundidad de concurrencia Java Concurrency in Practice es una lectura obligada.

Answer 2

Eche un vistazo a java.util.Observer /java.util.Observable. Son exactamente lo que estás buscando.

Answer 3

Puede utilizar 2 ExecutorServices, enviar una implementación invocable al servicio A que sabe acerca del seguimiento del servicio B. Cuando el Callable ha completado su trabajo, envía una nueva tarea al servicio B que hace algo adicional con los resultados.

Puede usar un CountDownLatch u otra barrera si necesita realizar trabajo adicional una vez que todos los artículos se han procesado en ambos servicios.

La aplicación ExecutorService es bastante sencilla, en su mayor parte probablemente uses algo como .newFixedThreadPool (int threads) y le envíes Runnables/Callables.

Answer 4

A continuación es un ejemplo para la comunicación entre el hilo:

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

class Chat { 
    boolean flag = false; 

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

    public synchronized void FromJam(String msg) { 
     if (!flag) { 
      try { 
       wait(); 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 
     } 

     System.out.println(msg); 
     flag = false; 
     notify(); 
    } 
} 

class T1 implements Runnable { 
    Chat m; 
    String[] s1 = { "Hello Jam", "How are you ?", "I am also doing fine!" }; 

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

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

class T2 implements Runnable { 
    Chat m; 
    String[] s2 = { "HI Sam", "I am good,And U ?", "ha haa" }; 

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

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