Java.Lang.IllegalMonitorStateException

La IllegalMonitorStateException está relacionada con la programación multiproceso. Este tutorial describe y demuestra la IllegalMonitorStateException en Java.

la java.lang.IllegalMonitorStateException en Java

La IllegalMonitorStateException se produce cuando se trabaja con programación multiproceso en Java. Cuando sincronizamos en un monitor y un subproceso intenta esperar o notificar a los otros subprocesos que esperan en el monitor sin poseerlo en ese momento, se produce la excepción IllegalMonitorStateException.

Si llamamos a los métodos wait(), notify(), o notifyAll() de la clase object, que no está en el bloque synchronized, se lanzará esta excepción. Probemos un ejemplo en este escenario.

package delftstack;

class DemoClass implements Runnable {
  public void run() {
    try {
      // The wait method is called outside the synchronized block
      this.wait(100);
      System.out.println("Thread can successfully run.");
    } catch (InterruptedException ex) {
      ex.printStackTrace();
    }
  }
}

public class Example {
  public static void main(String[] args) {
    DemoClass DemoRunnable = new DemoClass();
    Thread DemoThread = new Thread(DemoRunnable);
    DemoThread.start();
  }
}

El código anterior crea una clase que implementa la clase Ejecutable y luego llama al método esperar fuera del bloque sincronizado. El Ejemplo crea un hilo a partir de la instancia de DemoClass.

Lanzará la excepción IllegalMonitorStateException porque el método esperar se llama fuera del bloque sincronizado, y el subproceso debe poseer un bloqueo en el monitor antes de llamar al método esperar(). Ver salida:

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException: current thread is not owner
    at java.base/java.lang.Object.wait(Native Method)
    at delftstack.DemoClass.run(Example.java:7)
    at java.base/java.lang.Thread.run(Thread.java:833)

Para arreglar esta excepción, debemos llamar a los métodos wait(), notify(), o notifyAll() después de adquirir el bloqueo object, que estará en el bloque synchronized.

Ahora pongamos el método esperar() en el bloque sincronizado, luego haga que el código anterior no tenga errores. Ver ejemplo:

package delftstack;

class DemoClass implements Runnable {
  public void run() {
    synchronized (this) {
      try {
        // The wait method is called outside the synchronized block
        this.wait(100);
        System.out.println("Thread can successfully run.");
      } catch (InterruptedException ex) {
        ex.printStackTrace();
      }
    }
  }
}

public class Example {
  public static void main(String[] args) {
    DemoClass DemoRunnable = new DemoClass();
    Thread DemoThread = new Thread(DemoRunnable);
    DemoThread.start();
  }
}

Ahora el método esperar() está dentro del bloque sincronizado, y se adquiere el bloqueo en el monitor de objetos, el código se ejecutará con éxito. Ver salida:

Thread can successfully run.