Question

Consider the following code :-

public class UsingWait1{
public static void main(String... aaa){
    CalculateSeries r = new CalculateSeries();
    Thread t = new Thread(r);
    t.start();
    synchronized(r){
        try{
            r.wait();   //Here I am waiting on an object which is Runnable. So from its run method, it can notify me (from inside a synchronized block).
        } catch (InterruptedException e) {
            System.out.println("Interrupted");
        }

    }
    System.out.println(r.total);
    try{
        Thread.sleep(1);
    } catch (InterruptedException e){
        System.out.println("Interrupted");
    }
    System.out.println(r.total);

}
}

class CalculateSeries implements Runnable{
int total;
public void run(){
synchronized(this){
    for(int i = 1; i <= 10000; i++){
        total += i;
    }
    notify();   // Line 1 .. Notify Exactly one of all the threads waiting on this instance of the class to wake up
}
}
}

Here I am waiting on CalculateSeries which is Runnable. So I can notify the waiting thread from the run() method of CalculateSeries.

But now, consider the following code where I am waiting on an object which is not Runnable.

public class WaitNotOnThread{
public static void main(String... aaa){
    NotRunnable nr = new NotRunnable();
    IAmRunnable r = new IAmRunnable(nr);
    new Thread(r).start();
    synchronized(nr){
        try{
            nr.wait();
        } catch(InterruptedException e){
            System.out.println("Wait interrupted");             
        }

        System.out.println("After being notified within synchronized");
    }
    System.out.println("After synchronized");
}
}

class IAmRunnable implements Runnable{
NotRunnable nr;
IAmRunnable(NotRunnable nr){
    this.nr = nr;
}
public void run(){
    synchronized(nr){
        try{
            Thread.sleep(1000);
        } catch(InterruptedException e){
            System.out.println("Sleeping Interrupted :( ");
        }
        notify();                  // Line 2
    }
}
}

class NotRunnable{
}

Here I get an IllegalMonitorStateException at Line 2. I am waiting on the same instance of the object (which is not Runnable) while calling both, wait() as well as notify(). Then what is the problem?

Can someone also give some scenarios where it would be useful to wait on an object which is not Runnable??

Answer 1

Wait need not be on Runnable. That is why notify() is on Object and not on Runnable. I guess that helps in all cases we want to avoid busy wait.

The problem seems to be the synchronized() is on nr, and the notify is called on different object. Also synchronized should be on final variables.

class IAmRunnable implements Runnable {
     final NotRunnable nr;

    IAmRunnable( final NotRunnable nr) {
        this.nr = nr;
    }

    public void run() {
        synchronized (nr) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("Sleeping Interrupted :( ");
            }
            nr.notify();                  // Line 2
        }
    }
}