notifyAll()

[abalfazl hossein]

class WaitNotifyAllDemo
{
   public static void main (String [] args)
   {
      Object lock = new Object ();
      MyThread mt1 = new MyThread (lock);
      mt1.setName ("A");
      MyThread mt2 = new MyThread (lock);
      mt2.setName ("B");
      MyThread mt3 = new MyThread (lock);
      mt3.setName ("C");
      mt1.start ();
      mt2.start ();
      mt3.start ();
      System.out.println ("main thread sleeping");
      try
      {
         Thread.sleep (3000);
      }
      catch (InterruptedException e)
      {
      }
      System.out.println ("main thread awake");
      synchronized (lock)
      {
         lock.notifyAll ();
      }
   }
}
class MyThread extends Thread
{
   private Object o;
   MyThread (Object o)
   {
      this.o = o;
   }
   public void run ()
   {
      synchronized (o)
      {
         try
         {
             System.out.println (getName () + " before wait");
             o.wait ();
             System.out.println (getName () + " after wait");
         }
         catch (InterruptedException e)
         {
         }
      }
   }
}

http://www.javaworld.com/javaworld/jw-07-2002/jw-0703-java101.html?page=7


1-The only thread that uses ock.notifyAll (); is main thread who sleeps for 3000.Why synchronized is used here?

synchronized (lock) {
lock.notifyAll ();
}

[Sze Kong Chan]

The only thread that uses ock.notifyAll (); is main thread who sleeps for 3000.Why synchronized is used here?
synchronized (lock) {
lock.notifyAll ();
}

Although, only the main thread call lock.notifyAll(), but all 4 threads (including main) uses the lock object. Whenever any thread access a shared object, it is only safe to synchronized them. Because we don't know what the method do to the attributes within the shared object

Hope this help.

[abalfazl hossein]

These three threads, A, B , C , runs the code in run method in class MyThread.

I changed the code, But it stops:

class MyThread extends Thread {
      
      public synchronized void run ()   {
             
                    try  {
                           System.out.println (getName () + " before wait");
                           wait();
                           System.out.println (getName () + " after wait");
                    }
                    catch (InterruptedException e){ }
           }
   
}
class Main {
       public static void main (String [] args)  {
             Object lock = new Object ();
             MyThread mt1 = new MyThread ();
             mt1.setName ("A");
             MyThread mt2 = new MyThread ();
             mt2.setName ("B");
             MyThread mt3 = new MyThread ();
             mt3.setName ("C");
             mt1.start ();
             mt2.start ();
             mt3.start ();
            System.out.println ("main thread sleeping");
            try  {
               Thread.sleep (3000);
            }
            catch (InterruptedException e) {    }
            System.out.println ("main thread awake");
            synchronized (lock) {
            lock.notifyAll ();
            }
    }
}

A before wait
B before wait
C before wait
main thread sleeping
main thread awake

[Sze Kong Chan]

That is because you have change the MyThread.run to wait on each thread objects themselves. After which, nothing is going the notify them to wake up :0)..

In the original implementation, all of the MyThread instances are waiting on the same lock object, and the main thread will wake all of them up to print the "after wait" statement.

[abalfazl hossein]

Let me tell you what I understand from the first code:

1- 3 Threads are created.

2- These three threads uses one lock," o".

3- These threads lose lock, Because they call wait method.

4-Main thread take the "o" lock.

5-Main thread calls notifyAll()

6-These three methods wake up!


Please correct me if I am wrong.

[Sze Kong Chan]

abalfazl, I share the same understanding as you. This is what I think the original codes is doing.

[Campbell Ritchie]

Too difficult a question for "beginning". Moving thread.

[Campbell Ritchie]

Did you actually get that code from the Javaworld website?

I think you are correct in your understanding. I think the reason the main thread calls the notifyAll method is because the main thread is deciding when they should be woken, ie after the 3000ms wait.

[Campbell Ritchie]

By the way: I think you should tell us what it is you don't understand in the Javaworld article; we can help you better if we know that.

[Chris Hurst]

PS Don't use wait outside of a loop (its bad form) see http://download.oracle.com/javase/1.5.0/docs/api/java/lang/Object.html#wait%28%29