Practice question on synchronized

Hi, here's a question on using sync-ed blocks and calling wait(). Check the three correct options.

public class WaitLock{
    
    public static void main(String[] args){
        StringBuffer sb1=new StringBuffer("sb1");
        MyRunnable myRun=new MyRunnable(sb1);
        Thread t1=new Thread(myRun, "Thread 1");
        Thread t2=new Thread(myRun, "Thread 2");
        t1.start();
        t2.start();
    }
}
class MyRunnable implements Runnable{
    StringBuffer sb;
    MyRunnable(StringBuffer sb){
        this.sb=sb;
    }
    public void run(){
        synchronized(sb){
            try{
                System.out.println(Thread.currentThread().getName() + " Preparing to wait...");
                wait();
            }catch(InterruptedException ie){}
        }
    }
}
/*  Which three statements are true regarding the code above after trying 
 *  to compile it and run (select three)?
 *  A. This code doesn't compile.
 *  B. This code compiles but throws a runtime exception.
 *  C. This program compiles and runs but never completes.
 *  D. The current synchronized block in the run method is necessary at run time.
 *  E. Making run method synchronized will not change the flow of execution.
 *  F. Removing the synchronized block from run method can produce the same output.
 *  G. Only one thread will be able to enter the synchronized block during the program execution.
 *  H. The current call to wait() allows for the program to complete.
 **/

B,E,G

Why is this producing an IllegalMonitorStateException? (in the line where the wait method is called).

It feels like almost nobody wants to dig this question.

Well, B, G, and E should be an incorrect option altogether.

Y this is producing Exception can any one explain
regs
Vivek Nidhi

Originally posted by Vivek Nidhi:
Y this is producing Exception can any one explain
regs
Vivek Nidhi

The sync-ed block of code in MyRunnable allows one thread at a time to execute the code inside the run() method. Any thread that has acquired a lock on sb object can do it. The call to wait() looks like a perfectly legal request to put the currently executing thread to wait while making it release the lock on sb. However, it's not what's happening in the code!
This call to wait() would be good if the current thread had a lock on MyRunnable thread target object! You can think of wait(); as this.wait(); The thread entering the sync-ed block doesn't hold the lock on the currently executing instance of MyRunnable. Therefore, an IllegalMonitorStateException gets thrown. To avoid it, one should call wait on sb like that: sb.wait(); or make the whole run() sync-ed.
Figuring out the rest of correct answers follows the glitch above. Please let me know if anything was worded ambiguously. Otherwise, I hope this small gotcha helps learn the concept.

Instead of locking 'sb' object, if 'synchronized (this )' is used
then the run time exception would vanish .

Thanks every one
Vivek nidhi