# V6125\. Calling the 'wait', 'notify', and 'notifyAll' methods outside of synchronized context will lead to 'IllegalMonitorStateException'\.

The analyzer has detected that the 'wait', 'notify', and 'notifyAll' methods may be called outside a synchronized context\.

```cpp
public void someMethod() {
    notify();
}

public void anotherMethod() throws InterruptedException {
    wait();
}
```

The 'wait', 'notify', and 'notifyAll' methods [operate on](https://docs.oracle.com/en/java/javase/22/docs/api/java.base/java/lang/Object.html#notify()) the monitor of the object we need to synchronize on\. Their call is correct only in the synchronized context, which occurs on the same object\.

If the 'wait', 'notify', or 'notifyAll' methods are called in the non\-synchronized context, or if the current thread doesn't own the monitor of the object an 'IllegalMonitorStateException' exception will be thrown\.

The correct method usage in the 'synchronized' block:

```cpp
private final Object lock = new Object();

public void someCorrectMethod() {
    synchronized (lock) {
        lock.notify();
    }
}
```

Since the synchronization occurs on the 'lock' object, the call to the 'notify' method is correct only for the 'lock' object\.

The correct method usage in the 'synchronized' method:

```cpp
public synchronized void anotherCorrectMethod() {
    notifyAll();
}
```

The following code snippet is equivalent to the previous example:

```cpp
public void anotherCorrectMethod() {
    synchronized (this) {
        notifyAll();
    }
}
```

Thus, in this scenario, a call to the 'notifyAll' method is correct only for the 'this' object\.