wait(), notify, notifyAll() doubt

[sunil shah]

Hi,

The other day I was going through Kathy sierra/Bert bates book on SCJP and came across the code which is given as an example of wait/notify/notifyAll(chapter 9, code with classes - Reader and Calculator.). But the weird thing is that even if I remove the call to notify/notifyAll, the waiting threads come out of wait stage. Is this a case of spurious wake-up? I tried it on both windows and Linux machines but the results are more or less same.

Any help on this will be greatly appreciated.

Thanks,
Sunil

[Edward Harned]

Try posting this question on the author's site.

[sunil shah]

Hi Edward,

Could you please share the author's website URL? I tried searching it but could not find

Thanks in advance,

Sunil

[Henry Wong]

Please do a search, as most of K&B related questions has already been asked.

Also, it may help if you actually post the code, since not everyone have K&B handy.


Henry

[sunil shah]

Hi Henry,

I have searched for it but could not find any similar topic.

Following is the code I am talking about.

Please note that I have added a few println statements for my understanding.Also while loop for checking the value of variable c.finished is intentionally commented out.


public class Reader extends Thread
{
Calculator c;

public Reader(Calculator calc)
{
c = calc;
}

public void run() {
synchronized(c)
{
try
{
System.out.println("Waiting for calculation...");
//while(!c.finished)
c.wait();

System.out.println("Resume processing...");
}
catch (InterruptedException e) {System.out.println("Exception..."+e);}

}
System.out.println("Total is: " + c.total);
}

public static void main(String [] args)
{
Calculator calculator = new Calculator();

//calculator.start();
for(int i=0; i<20;i++)
{

new Reader(calculator).start();
}

calculator.start();

}
}


class Calculator extends Thread
{
int total;
int count;
boolean finished = false;

public void run() {
System.out.println(Thread.currentThread().getName()+" "+"Entered run method");
synchronized(this)
{

System.out.println(Thread.currentThread().getName()+" "+"Entered sync block");
for(int i=0;i<100;i++)
{
total += i;
}
//finished = true;
//notifyAll();
}
System.out.println(Thread.currentThread().getName()+" "+"Exiting run method");
}

}

[Henry Wong]

sunil shah wrote:
I have searched for it but could not find any similar topic.

See...

http://www.coderanch.com/t/233952/Threads-Synchronization/java/Threading-discrepancies


Summary: The Java library uses wait() and notifyAll() all on the thread object, to internally implement join() -- so don't use the thread object object as your notification object because of this.

Henry

[sunil shah]

Thanks a lot henry!! now it's crystal clear..........

I somehow missed the "thread discrepancies" post.....my sincere appologies for that.....

[Henry Wong]

Other somewhat related topics (if you are interested)...

http://www.coderanch.com/t/416345/Threads-Synchronization/java/notify-mandatory
http://www.coderanch.com/t/234368/Threads-Synchronization/java/wait-without-notify
http://www.coderanch.com/t/233142/Threads-Synchronization/java/synchronized-keywords-static-methods

Henry

[Jim Hoglund]

Below is a revised version of the code that you posted. It launches all the
MyReader threads and then starts one Calculator. Calculator then counts
to 100, sets ready=true, notifies the listeners and pauses to let a waiting
thread run. It then counts again, once for each MyReader thread. If you
take out the yield() statement, you can see the calculator rush ahead.
Some notify() calls may get lost and MyReader threads will be left waiting.

public class MyReader extends Thread {
   private final Calculator calc;
   private final static int readerCount = 9;

   public MyReader(Calculator c) {
      calc = c;
   }

   // wait()on calculator must be in condition loop and synchronized.
   // Resetting condition locks out other threads.   $$jah__
   public void run() {
      System.out.println(Thread.currentThread() + " MyReader.run()");
      try {
         synchronized (calc) {
            while (calc.ready == false) {
               calc.wait();
            }
            calc.ready = false;     // Added: 19-Mar-2010 $$jah__
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
      System.out.println(Thread.currentThread() + " total:" + calc.total);
   }

   // Start calculator before other threads. Pass calc object
   // to each thread for condition var and wait/notify(). $$jah__
   public static void main(String[] args) {
      Calculator calc = new Calculator(readerCount);
      for (int i = 0; i < readerCount; i++) {
         new MyReader(calc).start();
      }
      calc.start();
   }
}

class Calculator extends Thread {
   boolean ready = false;
   int readerCount;
   int total;

   Calculator(int c) {
      readerCount = c;
   }

   // Change condition and notify those waiting on calc (this).
   // Do this once for each MyReader.           $$jah__
   public void run() {
      System.out.println(Thread.currentThread() + " Calculator.run()");
      while (readerCount > 0) {
         for (int i = 0; i < 100; i++) {
            total++;
         }
         synchronized (this) {
            ready = true;
            notifyAll();
         }
         yield();  // Added: 19-Mar-2010   $$jah__
         readerCount--;
      }
   }
}

Notice how changing the 'ready' value is synchronized together with the
wait() and notify() calls. Also, the idiom of "while(condition==false) wait();"
should always be used. (I'm quoting from the Sun documentation.) Reset
of the condition variable after the wait() is important too.

Jim... ...