Question regarding notify() and wait()

[Jeff Schuler]

For the following code, I thought that the main thread would wait forever because the notify() statement is never run. Instead the "Total is" line was displayed. Does anyone know why?

    
class InterTest
{
    public static void main(String[] args)
    {
ThreadA t = new ThreadA();
t.start();
        
synchronized(t)
{
    try
    {
System.out.println("Waiting for t to complete...");
t.wait();
    } catch (InterruptedException e) {
e.printStackTrace();
    }
    System.out.println("Total is: " + t.total);
}
    }
}
 
class ThreadA extends Thread
{
    int total;
    
    public void run()
    {
 
        try {    
    sleep(2000);
} catch (InterruptedException e) {}
 
synchronized(this)
{
    System.out.println("In ThreadA synch block");
    for(int i=0; i < 100; i++)
    {
total++;
    }
    //System.out.println("Send Notify");
    //notify();
}
    }
}

[chintan ramavat]

Yeah could be. but if you use WAIT() overload version then it would interrupt as time goes down. here still it would be a guess saying b would run first. you can't since it's JVM dependent. but seems like if you don't notify then MAIN would get chance to run.

[Henry Wong]

wait() and notify() is used internally -- to implement the join() method. Basically, a notifyAll() is sent on the thread object, when a thread terminates, in order to wakeup all the threads waiting to join.

Henry

[kathir vel]

ThreadA is waiting(give up the lock to ThreadB) for ThreadB notify(),i.e to get object lock again.After ThreadB loop codes completion the lock will be released by ThreadB.So again threadA can get it back with out notification.

[kathir vel]

In this sample program also the same logic...with out notify waiting thread can continue execution once it get the object lock again.

class Reader extends Thread {
Calculator c;

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

public void run() {
synchronized(c) {
try {
System.out.println("Waiting for calculation...");
c.wait();
} catch (InterruptedException e) {}
System.out.println("Total is: " + c.total);
}
}

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

new Reader(calculator).start();
new Reader(calculator).start();
new Reader(calculator).start();
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("caluculate total is "+total);
// notifyAll();
}
}
}

[Jeff Schuler]

Originally posted by kathir vel:
In this sample program also the same logic...with out notify waiting thread can continue execution once it get the object lock again.

According to the K&B book the program will wait forever even if the lock is released. It does mention that sometimes the thread will sometimes start on it's own even without a notify() depending on the JVM. I wonder if this is the reason.

[Manfred Klug]

Originally posted by Jeff Schuler:
According to the K&B book the program will wait forever even if the lock is released. It does mention that sometimes the thread will sometimes start on it's own even without a notify() depending on the JVM. I wonder if this is the reason.

It's the same as with your example. The calculator thread calls notifyAll() on itself when it dies. But as you suppose, it will not work in the general case. look at the following example:

class MyRunnable implements Runnable {
    public void run() {
        synchronized (this) {
            System.out.println("Before waiting");
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("After waiting");
        }
    }
}
 
class Test {
    public static void main (String [] args) throws InterruptedException {
        MyRunnable r = new MyRunnable();
        new Thread(r).start();
        Thread.sleep(2000);
        synchronized (r) {
//            r.notify();
        }
        System.out.println("After notify");
    }
}

Without the notify, the second thread will wait forever.

[raj malhotra]

HI i have same concern .In K&B self test Answer explanation note, its written that once a thread finds wait() method it will wait forever if nobody call notify but in Khalid mughal its written that if notify() is not called for a particular period ,then waiting thread will wake up and it will not know the difference whether some one notify it or it wakes up itself....