用同步块替换volatile不起作用

Question

I was going through this tutorial. I understood the volatile keyword usage. But when i tried to achieve same result without using volatile keyword with doing operation on the concern variable with in synchronized block, it is not working. It throws IllegalMonitorStateException. Here is the modified code i tried.

public class VolatileTest {
private static Integer MY_INT = 0;

public static void main(String[] args) {
    new ChangeListener().start();
    new ChangeMaker().start();
}

static class ChangeListener extends Thread {
    @Override
    public void run() {
         synchronized(MY_INT){
        int local_value = MY_INT;
        while ( local_value < 5){
            if( local_value!= MY_INT){
                System.out.format("Got Change for MY_INT : {0}", MY_INT);
                 local_value= MY_INT; 
                  try {
                MY_INT.wait();
            } catch (Exception e) { e.printStackTrace(); }}
            }
        }
    }
}

static class ChangeMaker extends Thread{
    @Override
    public void run() {
         synchronized(MY_INT){
        int local_value = MY_INT;
        while (MY_INT <5){
            System.out.format("Incrementing MY_INT to {0}", local_value+1);
            MY_INT = ++local_value;
            try {
                MY_INT.notify();
            } catch (Exception e) { e.printStackTrace(); }
        }
    }
}}}

What I want to know is, in this case is volatile replaceable with synchronized block, if yes then how to do that? Thanks.

Answer 1

The problem is here:

 MY_INT = ++local_value;

MY_INT is an Integer variable, and when you assign a new value to it, the object that you are locking here:

 synchronized(MY_INT){

will be different to the object that you are notifying here:

  MY_INT.notify();

... and that will lead to the exception.

---

The solution is to make the lock object static final . Obviously that means you can't assign to it ... but that is the whole point!