Ufdjrw

How do threads that rely on one another communicate in Java?

For example, I am building a web crawler with threads that need data that comes from other threads.

That depends on the nature of the communication.

• Is it duplex (ie A talks to B and B talks to A)?


• Is it communication of data or communication of completion?


• and so on.

The simplest and most advisable form of inter-thread communication is simply to wait for the completion of other threads. That's most easily done by using Future:

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

The second task won't execute until the first completes.

Java 5+ has many concurrent utilities for dealing with this kind of thing. This could mean using LinkedBlockingQueues, CountDownLatch or many, many others.

For an in-depth examination of concurrency Java Concurrency in Practice is a must-read.

Below is example for Inter thread communication:

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]);
 
 

Take a look at java.util.Observer/java.util.Observable.
They are exactly what you are looking for.

You could use 2 ExecutorServices, submit a Callable implementation to service A that knows about follow on service B. When the Callable has completed it's work, it submits a new task to service B that does something additional with the results.

You could use a CountDownLatch or some other barrier if you need to perform additional work once all items have been processed in both services.

The ExecutorService api is pretty straight forward, for the most part you'll probably be using something like .newFixedThreadPool(int threads) and submitting Runnables/Callables to it.