Why does notifyAll() raise IllegalMonitorStateException when synchronized on Integer?

Question

Why does this test program result in a java.lang.IllegalMonitorStateException?

public class test {
    static Integer foo = new Integer(1);
    public static void main(String[] args) {
        synchronized(foo) {
            foo++;
            foo.notifyAll();
        }
        System.err.println("Success");
    }
}

Result:

Exception in thread "main" java.lang.IllegalMonitorStateException
        at java.lang.Object.notifyAll(Native Method)
        at test.main(test.java:6)

erickson · Accepted Answer · 2008-11-03T23:43:25.593

59

You have noted correctly that notifyAll must be called from a synchronized block.

However, in your case, because of auto-boxing, the object you synchronized on is not the same instance that you invoked notifyAll on. In fact, the new, incremented foo instance is still confined to the stack, and no other threads could possibly be blocked on a wait call.

You could implement your own, mutable counter on which synchronization is performed. Depending on your application, you might also find that AtomicInteger meets your needs.

edited Nov 03 '08 at 23:43

answered Nov 03 '08 at 23:37

erickson

265,237
58
395
493

I failed to realize that incrementing the Integer would allocate a new object instead of changing the value of the existing object. – jjvainio Nov 03 '08 at 23:50
1

Trying to wait/notify using an Enum can also lead to this condition: `synchronized (myEnum) { myEnum=MyEnum.NEW_VALUE; myEnum.notify(); }` – dmitrii Jun 17 '11 at 16:56
For those looking for a solution to a boolean, use AtomicBoolean as the wrapper type – Oded Breiner Aug 18 '14 at 18:56
2

@dmitrii, yes indeed, but here you are explicitly modifying the reference. That applies to ANY object reference, not only enums. – coffee_machine Sep 17 '14 at 09:58
It's very tempting to use a primitive type wrapper both as the synchronizer and the condition data. What a mistake! – vehsakul Sep 26 '15 at 17:24

score 3 · Answer 2 · answered Nov 03 '08 at 23:47

3

You should also be leery of locking or notifying on objects like String and Integer that can be interned by the JVM (to prevent creating a lot of objects that represent the integer 1 or the string "").

answered Nov 03 '08 at 23:47

dbt

39
1

Eric Leschinski · Answer 3 · 2012-05-09T15:50:52.527

Incrementing the Integer makes the old foo disappear and be replaced with a brand new object foo which is not synchronized with the previous foo variable.

Here is an implementation of AtomicInteger that erickson suggested above. In this example foo.notifyAll(); does not produce a java.lang.IllegalMonitorStateException beause the AtomicInteger Object is not refreshed when foo.incrementAndGet(); is run.

import java.util.concurrent.atomic.AtomicInteger;

public class SynchronizeOnAPrimitive {
    static AtomicInteger foo = new AtomicInteger(1);
    public static void main(String[] args) {
        synchronized (foo) {
            foo.incrementAndGet();
            foo.notifyAll();
        }
        System.out.println("foo is: " + foo);
    }
}

Output:

foo is: 2

score 1 · Answer 4 · answered Nov 03 '08 at 23:43

As erickson has noted, the code without the postincrement operator works without error:

static Integer foo = new Integer(1);

public static void main(String[] args) {
    synchronized (foo) {
        foo.notifyAll();
    }
    System.out.println("Success");
}

output:

Success

Why does notifyAll() raise IllegalMonitorStateException when synchronized on Integer?

4 Answers4

Linked

Related