IllegalMonitorStateException from notify()

[Joss Armstrong]

Please can someone explain to me why the following code gives an IllegalMonitorStateException when the notify method is called?

N.B. It works correctly when a public Object o is instantiated in the Example1 class and this is used to synchronize on.

view plaincopy to clipboardprint?

public class Example1 {  
    public Integer total = 0;  
  
    public static void main(String[] args) {  
        Example1 e1 = new Example1();  
        e1.doStuff();  
    }  
  
    public void doStuff() {  
        System.out.println("Starting");  
        synchronized (total) {  
            System.out.println("Waiting");  
            A a = new A(this);  
            a.start();  
            try {  
                total.wait();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            System.out.println("Total=" + total);  
        }  
    }  
  
}  
  
class A extends Thread {  
    private Example1 example1;  
  
    public A(Example1 e) {  
        example1 = e;  
    }  
  
    public void run() {  
        synchronized (example1.total) {  
            for (int i = 0; i < 10; i++) {  
                example1.total += i;  
            }  
            example1.total.notify();  
        }  
    }  
}    

Thanks

Joss Armstrong

[Henry Wong]

public void run() { 
    synchronized (example1.total) { 
        for (int i = 0; i < 10; i++) { 
            example1.total += i; 
        } 
        example1.total.notify(); 
    }
} 

Remember that synchronization is based on objects (and not references)..... hint.... is the object whose notify() method is called, the same as the object that is used to synchronize on?

Henry

[Joss Armstrong]

I understand now that this error is caused by the updating of the object within the synchronized method.

Thank you very much for your help.

Joss Armstrong

[Nidhi Sar]

I understand now that this error is caused by the updating of the object within the synchronized method.

Hold on a moment... why can't you update an object that you hold a lock to within synchronized method??

If we change the code to synchronize on example1 instead of example1.total, it works fine. But updating total is updating the state of example1 too. [After all total is an instance variable of Example1 class]

  
// This works fine. Why does this work when the previous code gives runtime error???
public class Example1 {
	public Integer total = 0;

	public static void main(String[] args) {
		Example1 e1 = new Example1();
		e1.doStuff();
	}

	public void doStuff() {
		System.out.println("Starting");
		synchronized (this) {    //synchronizing on 'this' instead of this.total
			System.out.println("Waiting");
			A a = new A(this);
			a.start();
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println("Total=" + total);
		}
	}
}

class A extends Thread {
	private Example1 example1;

	public A(Example1 e) {
		example1 = e;
	}

	public void run() {
		synchronized (example1) {  //synchronizing on 'example1' instead of 'example1.total'
			for (int i = 0; i < 10; i++) {
				example1.total += i;   //here we ARE CHANGING example1, since we change the value of a variable of example1
			}
			example1.notify();
		}
	}
}
  

[Ankit Garg]

Nidhi Sar wrote:Hold on a moment... why can't you update an object that you hold a lock to within synchronized method??

I hope that you know the difference between object and reference. Keeping that in mind, you can update an object to which you hold the lock. Example

class MySynchronized {
    int a = 10;
    public static void main(String[] args) {
        MySynchronized ms = new MySynchronized();
        synchronized(ms) {
            ms.a = 20;  //fine
        }
    }
}

The reason Joss' code didn't work is because we called the notify method on a different object and synchronized on a different object. The reference was the same, but the object was different. The original code does a work similar to the following code

class MySynchronized {
    int a = 10;
    public static void main(String[] args) {
        MySynchronized ms = new MySynchronized();
        synchronized(ms) {
            ms = new MySynchronized();
            ms.notify();   //IllegalMonitorStateException, we don't hold the lock to the object 
                           //on which we called notify
        }
    }
}

[Nidhi Sar]

Ankit Garg wrote:The reason Joss' code didn't work is because we called the notify method on a different object and synchronized on a different object. The reference was the same, but the object was different.

Hi Ankit,

Thanks so much! That's great explanation. Somehow, I thought the following line was just changing the state of example1.total Integer object. But ofcourse, it creates a new object (unboxing, adding i, boxing) and gives it the same reference. My mistake

example1.total += i;

[Abimaran Kugathasan]

Hi, All....

If we don't synchronized both blocks(which have wait() and notify() methods within them), We don't get any Compilation error. But the 'communication' between them doesn't work. OK

[Ankit Garg]

Abimaran Kugathasan wrote:If we don't synchronized both blocks(which have wait() and notify() methods within them), We don't get any Compilation error. But the 'communication' between them doesn't work. OK

Is this a question or answer??

[Abimaran Kugathasan]

Ankit wrote ...

Is this a question or answer??

This is correct? Please confirm?

[Ankit Garg]

If we don't call wait or notify method in synchronized context (synchronized on the object on which we are calling wait or notify), then we don't get any compilation error but an IllegalMonitorStateException at runtime...