IllegalMonitorStateException in Java

1. Overview

In this short tutorial, we'll learn about java.lang.IllegalMonitorStateException. 

We'll create a simple sender-receiver application that throws this exception. Then, we'll discuss possible ways of preventing it.  Finally, we'll show how to implement these sender and receiver classes correctly.

2. When Is It Thrown?

The IllegalMonitorStateException is related to multithreading programming in Java. If we have a monitor we want to synchronize on, this exception is thrown to indicate that a thread tried to wait or to notify other threads waiting on that monitor, without owning it. In simpler words, we'll get this exception if we call one of the wait(), notify(), or notifyAll() methods of the Object class outside of a synchronized block.

Let's now build an example that throws an IllegalMonitorStateException. For this, we'll use both wait() and notifyAll() methods to synchronize the data exchange between a sender and a receiver.

Firstly, let's look at the Data class that holds the message we're going to send:

public class Data {
    private String message;
    public void send(String message) {
        this.message = message;
    }
    public String receive() {
        return message;
    }
}

Secondly, let's create the sender class that throws an IllegalMonitorStateException when invoked. For this purpose, we'll call the notifyAll() method without wrapping it in a synchronized block:

class UnsynchronizedSender implements Runnable {
    private static final Logger log = LoggerFactory.getLogger(UnsychronizedSender.class);
    private final Data data;
    public UnsynchronizedSender(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            data.send("test");
            data.notifyAll();
        } catch (InterruptedException e) {
            log.error("thread was interrupted", e);
            Thread.currentThread().interrupt();
        }
    }
}

The receiver is also going to throw an IllegalMonitorStateException. Similarly to the previous example, we'll make a call to the wait() method outside a synchronized block:

public class UnsynchronizedReceiver implements Runnable {
    private static final Logger log = LoggerFactory.getLogger(UnsynchronizedReceiver.class);
    private final Data data;
    private String message;
    public UnsynchronizedReceiver(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
        try {
            data.wait();
            this.message = data.receive();
        } catch (InterruptedException e) {
            log.error("thread was interrupted", e);
            Thread.currentThread().interrupt();
        }
    }
    public String getMessage() {
        return message;
    }
}

Finally, let's instantiate both classes and send a message between them:

public void sendData() {
    Data data = new Data();
    UnsynchronizedReceiver receiver = new UnsynchronizedReceiver(data);
    Thread receiverThread = new Thread(receiver, "receiver-thread");
    receiverThread.start();
    UnsynchronizedSender sender = new UnsynchronizedSender(data);
    Thread senderThread = new Thread(sender, "sender-thread");
    senderThread.start();
    senderThread.join(1000);
    receiverThread.join(1000);
}

When we try to run this piece of code, we'll receive an IllegalMonitorStateException from both UnsynchronizedReceiver and UnsynchronizedSender classes:

[sender-thread] ERROR com.baeldung.exceptions.illegalmonitorstate.UnsynchronizedSender - illegal monitor state exception occurred
java.lang.IllegalMonitorStateException: null
	at java.base/java.lang.Object.notifyAll(Native Method)
	at com.baeldung.exceptions.illegalmonitorstate.UnsynchronizedSender.run(UnsynchronizedSender.java:15)
	at java.base/java.lang.Thread.run(Thread.java:844)
[receiver-thread] ERROR com.baeldung.exceptions.illegalmonitorstate.UnsynchronizedReceiver - illegal monitor state exception occurred
java.lang.IllegalMonitorStateException: null
	at java.base/java.lang.Object.wait(Native Method)
	at java.base/java.lang.Object.wait(Object.java:328)
	at com.baeldung.exceptions.illegalmonitorstate.UnsynchronizedReceiver.run(UnsynchronizedReceiver.java:12)
	at java.base/java.lang.Thread.run(Thread.java:844)

3. How to Fix It

To get rid of the IllegalMonitorStateException, we need to make every call to wait(), notify(), and notifyAll() methods within a synchronized block. With this in mind, let's see how the correct implementation of the Sender class should look like:

class SynchronizedSender implements Runnable {
    private final Data data;
    public SynchronizedSender(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
        synchronized (data) {
            data.send("test");
            data.notifyAll();
        }
    }
}

Note we're using the synchronized block on the same Data instance we later call its notifyAll() method.

Let's fix the Receiver in the same way:

class SynchronizedReceiver implements Runnable {
    private static final Logger log = LoggerFactory.getLogger(SynchronizedReceiver.class);
    private final Data data;
    private String message;
    public SynchronizedReceiver(Data data) {
        this.data = data;
    }
    @Override
    public void run() {
        synchronized (data) {
            try {
                data.wait();
                this.message = data.receive();
            } catch (InterruptedException e) {
                log.error("thread was interrupted", e);
                Thread.currentThread().interrupt();
            }
        }
    }
    public String getMessage() {
        return message;
    }
}

If we again create both classes and try to send the same message between them, everything works well, and no exception is thrown.

4. Conclusion

In this article, we learned what causes IllegalMonitorStateException and how to prevent it.

As always, the code is available over on GitHub.

The post IllegalMonitorStateException in Java first appeared on Baeldung.