Understanding IllegalMonitorStateException with Java's wait and notify Methods

Why do I encounter IllegalMonitorStateException when using wait and notify in Java?

Main.main.wait();

In Java, the `IllegalMonitorStateException` occurs when a thread attempts to call the `wait()` or `notify()` method without holding the intrinsic lock of the object. To properly use these methods, synchronization must be correctly handled. This explanation will clarify how to implement wait and notify correctly, ensuring all threads are notified appropriately without exceptions.

synchronized(Main.class) {
    Main.main.wait();
}

synchronized (Main.class) {
    System.out.println("Runners ready.");
    Main.main.notifyAll();
}

Causes

• Calling wait() or notify() on an object without holding its monitor lock (i.e., without synchronizing on that object).
• Using `wait()` or `notify()` from outside a synchronized block, which violates Java's synchronization rules.

Solutions

• Wrap the wait() and notifyAll() calls within synchronized blocks on the same object to ensure the calling thread holds the intrinsic lock.
• Use `synchronized(Main.class)` in the `main()` method to call notifyAll() and make sure `wait()` is called within a synchronized block in the Runner class.

Mistake: Not synchronizing the threads properly before calling wait or notify methods.

Solution: Always synchronize on the object whose wait or notify you are calling.

Mistake: Assuming that notify() would wake all waiting threads without using notifyAll().

Solution: Use notifyAll() when you want to awaken all waiting threads instead of just one.