<p>Why does this test program result in a <code>java.lang.IllegalMonitorStateException</code>?</p>

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

<p>Result:</p>

<pre><code>Exception in thread "main" java.lang.IllegalMonitorStateException
        at java.lang.Object.notifyAll(Native Method)
        at test.main(test.java:6)
</code></pre>

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.