Regarding Notify

[Saral Saxena]

Hi Folks..

I was going through threads and I read that ..The notify() method is used to send a signal to one and only one of the threads that are waiting in that same object's waiting pool. The method notifyAll() works in the same way as notify(), only it sends the signal to all of the threads waiting on the object....Now my query is that if Lets say I have 5 threads waiting and through Notify() , i want to send to notification to thread 3 only, what logic should be there that notification is sent to thread 3 only ..!!

I have come up with the code..

public class Main {

	  public static void main(String[] args) {
	    Main m = new Main();
	    m.start(5);
	  }


	  private void start(int n) {
	    MyThread[] threads = new MyThread[n];
	    for (int i = 0; i < n; i++) {
	      threads[i] = new MyThread();
	      threads[i].setDaemon(true);
	      threads[i].start();
	    }
	    
	    
	    /* wait for the threads to start */
	    try {
	      Thread.sleep(500);
	    } catch (InterruptedException ex) {
	      ex.printStackTrace();
	    }
	    threads[2].setCanContinue(true);
	    synchronized (lock) {
	      lock.notifyAll();
	    }
	    for (int i = 0; i < n; i++) {
	      try {
	        threads[i].join(500);
	      } catch (InterruptedException ex) {
	        ex.printStackTrace();
	      }
	    }
	    System.out.println("Done!");
	  }

	  private final Object lock = new Object();

	  private final class MyThread extends Thread {
	    private volatile boolean canContinue;
	    @Override
	    public void run() {
	      System.out.println(Thread.currentThread().getName() + " going to wait...");
	      synchronized (lock) {
	        while (!canContinue) {
	          try {
	            lock.wait(1000); /* one second */
	          } catch (InterruptedException ex) {
	            ex.printStackTrace();
	          }
	        }
	      }
	      System.out.println(Thread.currentThread().getName() + " woken up!");
	    }
	    public void setCanContinue(boolean canContinue) {
	      this.canContinue = canContinue;
	    }
	  };
	}

The ouput will be...

Thread-0 going to wait...
Thread-3 going to wait...
Thread-2 going to wait...
Thread-4 going to wait...
Thread-1 going to wait...
Thread-2 woken up!
Done!

So you can clearly see that only the third thread (indexed from zero) is woken up.

But please advise me any simpler code to achieve the same thing as this code is still not clear to me, ..!!

[Steve Luke]

Simpler code would include the use of Locks and Conditions, rather than Object.wait() and Object.notify(). See The High Level Concurrency Tutorial for info on how to use them. Pseudo-codish example might be:

public class MyThread implements Runnable
{
  private final Lock syncOn;
  private final Condition wakeOn;

  public MyThread(Lock toSync, Condition toWake)
  {
    this.syncOn = toSync;
    this.wakOn = toWake;
  }

  public void run()
  {
    //precursor code ...

    this.syncOn.lock();
    try
    {
      //stuff to synchronize ...

      this.wakeOn.await();

      //...
    } finally {
      this.syncOn.unlock();
    }
  }
}

//...
    //when creating threads...
    Lock syncLock = new ReentrantLock();
    Condition[] conditions = new Conition[threadCount];
    for (int i = 0; i < threadCount; i++)
    {
      conditions[i] = syncLock.newCondition();
      MyTask task = new MyTask(syncLock, conditions[i]);
      Thread toRunTask = new Thread(task);
      toRunTask.setDaemon(true);
      toRunTask.start();
    }

//...
    //To wake up task 3...
    syncLock.lock();
    try
    {
      conditions[2].signal();
    } finally {
      syncLock.unlock();
    }