Java问题记录——IllegalMonitorStateException

Java问题记录——IllegalMonitorStateException

摘要：本文主要分析了IllegalMonitorStateException的产生原因。

部分内容来自以下博客：

https://blog.csdn.net/historyasamirror/article/details/6709693

锁对象发生了改变

在测试多线程通信的代码时，出现了这个异常。

代码分析

代码如下：

 public class Demo {
     public static void main(String[] args) {
         DemoThread demoThread = new DemoThread();
         Thread thread1 = new Thread(demoThread);
         Thread thread2 = new Thread(demoThread);
         thread1.start();
         thread2.start();
     }
 }

 class DemoThread implements Runnable {
     private Integer num = 1;

     @Override
     public void run() {
         while (true) {
             synchronized (num) {
                 num.notify();
                 if (num <= 10) {
                     System.out.println(Thread.currentThread().getName() + " >>> " + num++);
                     try {
                         num.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
     }
 }

运行结果如下：

 Thread-0 >>> 1
 Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
     at java.lang.Object.notify(Native Method)
     at com.iyao.ide.engine.task.DemoThread.run(Demo.java:22)
     at java.lang.Thread.run(Thread.java:745)
 Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
     at java.lang.Object.wait(Native Method)
     at java.lang.Object.wait(Object.java:502)
     at com.iyao.ide.engine.task.DemoThread.run(Demo.java:26)
     at java.lang.Thread.run(Thread.java:745)

说明

在网上查找资料，发现需要在调用wait()或者notify()之前，必须使用synchronized语义绑定住被wait/notify的对象。

可问题是，在上面的代码中，已经对num这个变量使用了synchronzied，然后才调用的num.wait()。按理不应该抛出这个异常。

真正的问题在于num这个变量是一个Integer，并且，在调用num.wait()之前，num执行了一次自增操作。

Integer型变量在执行自增的时候，其实是创建了一个新的对象。简单的说，在自增的之前和之后，num并不是同一个对象。

synchronzied(num)绑定的是旧的Integer对象，而num.wait()使用的是新的Integer对象。由于新的Integer对象并没有使用synchronzied进行同步，所以系统抛出了IllegalMonitorStateException异常。

相同的悲剧还有可能出现在num是Boolean或者String类型的时候。

一个解决方案是采用java.util.concurrent.atomic中对应的类型，比如这里就应该是AtomicInteger。采用AtomicInteger类型，可以保证对它的修改不会产生新的对象。

解决方案

代码修改后如下：

 public class Demo {
     public static void main(String[] args) {
         DemoThread demoThread = new DemoThread();
         Thread thread1 = new Thread(demoThread);
         Thread thread2 = new Thread(demoThread);
         thread1.start();
         thread2.start();
     }
 }

 class DemoThread implements Runnable {
     private AtomicInteger num = new AtomicInteger(1);

     @Override
     public void run() {
         while (true) {
             synchronized (num) {
                 num.notify();
                 if (num.intValue() <= 10) {
                     System.out.println(Thread.currentThread().getName() + " >>> " + num.getAndAdd(1));
                     try {
                         num.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
     }
 }

运行结果如下：

 Thread-0 >>> 1
 Thread-1 >>> 2
 Thread-0 >>> 3
 Thread-1 >>> 4
 Thread-0 >>> 5
 Thread-1 >>> 6
 Thread-0 >>> 7
 Thread-1 >>> 8
 Thread-0 >>> 9
 Thread-1 >>> 10

结论

在使用锁的时候要注意锁住的对象是谁，是否发生过改变。