How Do You Avoid IllegalMonitorStateException When Using Java\'s wait() and notify()?

Java Wait and Notify: Understanding IllegalMonitorStateException

In Java, wait() and notify() methods are used to synchronize threads. However, if improperly used, the IllegalMonitorStateException can be encountered.

Problem

The code snippet below demonstrates a simple synchronization issue:

<code class="java">class Main {
    // ...
    public void wait() {
        // ...
    }
    public void notifyAll() {
        // ...
    }
}

class Runner implements Runnable {
    public void run() {
        try {
            Main.main.wait();
        } catch (InterruptedException e) {
            // ...
        }
    }
}</code>

In this example, the Runner thread attempts to call wait() on the Main object. However, this leads to the exception because the Runner thread does not own the monitor associated with the Main object.

Understanding Synchronized Methods

To use wait() and notify(), the current thread must own the monitor of the object being synchronized. This can be achieved by synchronizing on the object using the synchronized keyword.

Solution

To fix the issue, the Runner class can be modified as follows:

<code class="java">class Runner implements Runnable {
    public void run() {
        try {
            synchronized(Main.main) {
                Main.main.wait();
            }
        } catch (InterruptedException e) {
            // ...
        }
    }
}</code>

By adding the synchronized block around the wait() call, the Runner thread becomes the owner of the Main object's monitor and can safely perform the wait operation.

Applying to notifyAll

The same principle applies to notify() and notifyAll() methods. They must be called from within a synchronized block of the object being synchronized. Therefore, the Main class can be modified as follows:

<code class="java">class Main {
    // ...
    public synchronized void notifyAll() {
        // ...
    }
}</code>

By ensuring proper ownership of monitors, the use of wait() and notify() can be safely implemented to synchronize threads in Java.

The above is the detailed content of How Do You Avoid IllegalMonitorStateException When Using Java\'s wait() and notify()?. For more information, please follow other related articles on the PHP Chinese website!