Why does it seem like notify() acts like notifyAll() for threads?

Question

I'm running a little exercise here:
class Reader extends Thread {
      Calculator c;
       String name ="Fred";
       static int i = 0;
      public Reader(Calculator calc) {
         c = calc;
         name = "Fred"+(i++);
      public void run() {
         synchronized(c) {
           try {
              System.out.println(name + " is waiting for calculation...");
              c.wait();
           } catch (InterruptedException e) {}
           System.out.println("Total is: " + c.total + " for "+name);
     public static void main(String [] args) {
        Calculator calculator = new Calculator();
        new Reader(calculator).start();
        new Reader(calculator).start();
        new Reader(calculator).start();
        try {
             Thread.sleep(1000);
          } catch (InterruptedException e) {
               System.out.println("Got interrupted");
        calculator.start();
  class Calculator extends Thread {
     int total;
     public void run() {
        synchronized(this) {
           for(int i=0;i<100;i++) {
              total += i;
           System.out.println("Notifying start");
           notify();
           System.out.println("Notifying end");
  }the output is
Fred0 is waiting for calculation...
Fred1 is waiting for calculation...
Fred2 is waiting for calculation...
Notifying start
Notifying end
Total is: 4950 for Fred0
Total is: 4950 for Fred2
Total is: 4950 for Fred1
I expect only one "Total is: ..." output to come out since I expect only one thread to wake up from its waiting state from that notify() call. However all three threads wake up. What am I misunderstanding? I thought a thread waits forever unless you pass a time parameter into wait()... or am I wrong?
Edited by: lapchern on Nov 17, 2009 12:53 PM

Answer 1

Well, first of all, don't discard Exceptions and then wonder about the behaviour of a program :-).
But that's not the issue here. From some quick testing, I didn't get the same behaviour when I ran using wait/notify on a lock object, not the thread itself:
public class WaitNotify extends Thread {
      Calculator c;
     String name ="Fred";
     static int i = 0;
      public WaitNotify(Calculator calc) {
         c = calc;
         name = "Fred"+(i++);
      public void run() {
         synchronized(c.lock) {
           try {
              System.out.println(name + " is waiting for calculation...");
              c.lock.wait();
           } catch (InterruptedException e) {
              e.printStackTrace();
           System.out.println("Total is: " + c.total + " for "+name);
     public static void main(String [] args) {
        Calculator calculator = new Calculator();
        new WaitNotify(calculator).start();
        new WaitNotify(calculator).start();
        new WaitNotify(calculator).start();
        try {
         Thread.sleep(1000);
      } catch (InterruptedException e) {
         System.out.println("Got interrupted");
        calculator.start();
  class Calculator extends Thread {
     int total;
     final Object lock = new Object();
     public void run() {
        synchronized(lock) {
           for(int i=0;i<100;i++) {
              total += i;
           System.out.println("Notifying start");
           lock.notify();
           System.out.println("Notifying end");
  }Not sure ATM why that is, but it's I think best practice not to lock on the Thread itself and instead a different Object, so there's a fix. It'll give you a place to start investigating.
Edit: Might be good to look at the [Javadoc for Object.wait()|http://java.sun.com/javase/6/docs/api/java/lang/Object.html#wait()]:
...interrupts and spurious wakeups are possible, and this method should always be used in a loop:
     synchronized (obj) {
while (<condition does not hold>)
obj.wait();
... // Perform action appropriate to condition
Edited by: endasil on 17-Nov-2009 4:08 PM
Edited by: endasil on 17-Nov-2009 4:09 PM