By Using the concept called Inter Thread Communication

using wait() and notify() two different class threads
communicate with each other. 
For example:

public class LoggingThread extends Thread {
  private LinkedList linesToLog = new LinkedList();
  private volatile boolean terminateRequested;

  public void run() {
    try {
      while (!terminateRequested) {
        String line;
        synchronized (linesToLog) {
          while (linesToLog.isEmpty())
            linesToLog.wait();
          line = (String) linesToLog.removeFirst();
        }
        doLogLine(line);
      }
    } catch (InterruptedException ex) {
      Thread.currentThread().interrupt();
    }
  }

  private void doLogLine(String line) {
    // ... write to wherever
  }

  public void log(String line) {
    synchronized (linesToLog) {
      linesToLog.add(line);
      linesToLog.notify();
    }
  }
}

Below I am showing the best example for ur Query.


class Rack
{
 int n;
 boolean avialable  = false;
 synchronized int get()
 {
  if(!avialable )
  try
  {
   wait();
  }
  catch(InterruptedException e)
  {  
   System.out.println("InterruptedException caught");
  }
  System.out.println("got:" + n);
  avialable  = false;
  notify();
  return n;
 }

 synchronized int put(int n)
 {
  if(avialable )
  try
  {
   wait();
  }
  catch(InterruptedException e)
  {  
   System.out.println("InterruptedException caught");
  }
  this.n = n;
  avialable  = true;
  System.out.println("put:" + n);
  notify();
  return n;
  }
}

class Producer implements Runnable
{
Rack k;
Producer(Rack k)
{
this.k = k;
new Thread(this, "Producer").start();
}
public void run()
{
int i = 1;
while(true)
{
k.put(i++);
}
}
}
class Consumer implements Runnable
{
Rack k;
Consumer(Rack k)
{
this.k = k;
new Thread(this, "Consumer").start();
}
public void run()
{
while(true)
{
k.get();
}
}
}
class ProducerConsumerProblem
{
 public static void main(String args[])
    {
	Rack k = new Rack();
	new Producer(k);
	new Consumer(k);
	System.out.println("press control - c to stop. ");
     }
}

The threads in java follow Mutual exclusion( synchronized)
and co-operation; 

for co-operation they need to talk to each other by messages
saying " i am waiting in the wait q anyone can acquire the
lock of the object" or" i have acquired the lock now by
notify() to the last thread who called wait() or by
notifyall() to all the threads who are in the wait q"