notifyAll() not working

[Vidya Venkatesh]

hello friends
In this program I'm not able to bring the thread t1 out of the waiting state. Isn't notifyAll() supposed to wake up all waiting threads. Am I doing anything wrong ?
class TestThread extends Thread {
public void startMe()
{
synchronized(this)
{

notifyAll();
System.out.println("Not");
}
}
public void run() {
try
{
synchronized(this)
{
wait();
System.out.println("Notified");
}
}
catch(InterruptedException e)
{}
}
public static void main(String[] args) {
TestThread t1 = new TestThread();
t1.start();
t1.startMe();
}
}
Thanks
Vidya
[ April 23, 2003: Message edited by: Vidya Venkatesh ]

[Rory French]

The problem arises because your t1.startMe() method is being invoked before your t1 thread runs. Consequently, the call to notifyAll() is invoked before the call to wait(). If this happens (i.e. notify is called before wait), the thread could wait forever unless another notify call is made on the same object.
It is good practice therefore to put in a test condition before calling wait to avoid the problem. I have ammended your code to provide an example of such a test condition.

  
class TestThread extends Thread {
  //** create a test flag
  private boolean flag = false;
  public void startMe() {
    synchronized(this) {
      notifyAll();
      //** set flag
      flag = true;
      System.out.println("Not");
    }
  }
  public void run() {
    try {
      synchronized(this) {
        //** call wait only if notify has not
        //** already been called
        while (flag == false) {   wait();
          System.out.println("Notified");
        }
      }
    }
    catch(InterruptedException e){}
  }
  public static void main(String[] args) {
    TestThread t1 = new TestThread();
    t1.start();
    t1.startMe();
  }
}

Alternatively, if you want your program to run as is AND output "Notified", you could invoke the Thread.sleep() method on your main thread (i.e. the one that calls t1.startMe()) with a time parameter, directly after the call to t1.start(). This would give thread t1 a chance to run and call wait() before the call to notifyAll().
Hope this helps.
[ April 23, 2003: Message edited by: Rory French ]
[ April 23, 2003: Message edited by: Rory French ]
[ April 23, 2003: Message edited by: Rory French ]

[Vidya Venkatesh]

Thanks so much. Now it is clear to me
Vidya

[John Zoetebier]

The solution offered by Rory prevents an eternal wait, but does not show that notifyAll() wakes all waiting threads.
If you just run the program a number of times you will see that wait() is never called.
It is not difficult to see why.
The main thread is already running. Consequently method startMe() will already have run by the time the second thread is executing.
To show that notifyAll() really wakes up the second thread call join on the second thread with a timeout of about 1 second, depending on the speed of your processor.
The following is a modifed version what shows this point:

  
class TestThread extends Thread {
  //** create a test flag
  private boolean canWait = true;
public void startMe() {
synchronized(this) {
notifyAll();
//** set flag
canWait = false;
System.out.println("Notify");
}
}
public void run() {
try {
synchronized(this) {
//** call wait only if notify has not already been called
// Main thread waits until we are waiting
System.out.println("Please wait ...");
if (canWait) { 
wait();
System.out.println("Wait over");
}
}
}
catch(InterruptedException e){
// do nothing
}
}
public static void main(String[] args) {
TestThread t1 = new TestThread();
t1.start();
try {
t1.join(1000);// wait a while for this thread
//t1.join();// will not work as we will wait forever
} catch (InterruptedException e) {
// do nothing
}
t1.startMe();
}
}