多线程编程中wait方法引发IllegalMonitorStateException原因及解决方案

多线程编程中使用`wait()`方法时，如果未持有对象的监视器锁，就会抛出`IllegalMonitorStateException`异常。本文分析了三个线程按顺序打印ID时，因错误使用`wait()`和`notifyAll()`方法导致该异常的原因。 问题源于代码中使用`volatile`变量作为锁对象，并在`synchronized`块内修改了该变量，导致线程调用`wait()`时持有锁对象与唤醒后释放的锁对象不一致。解决方案是使用一个独立的锁对象来控制同步，避免在持有锁的同时修改锁对象，从而确保`wait()`方法始终在正确的锁对象上操作，有效避免`IllegalMonitorStateException`异常。

多线程编程中wait()方法抛出IllegalMonitorStateException异常的解析

本文分析一个多线程编程问题：三个线程(a、b、c)按顺序打印ID五次(abcabc...)，使用wait()和notifyAll()方法同步，却抛出IllegalMonitorStateException异常。

问题描述: 程序使用volatile字符串变量current_thread控制线程执行顺序，并用synchronized块和wait()、notifyAll()方法进行同步。然而，运行时出现IllegalMonitorStateException。

错误代码片段:

// 线程打印完毕后，设置下一个要打印的线程标识，并唤醒其他线程
if (current_thread.equals("a")) {
    current_thread = "b";
} else if (current_thread.equals("b")) {
    current_thread = "c";
} else if (current_thread.equals("c")) {
    current_thread = "a";
}

完整代码(略有修改，方便理解):

package 并发编程.work2;

public class Test {
    private static volatile String current_thread = "A";
    private static final Object lock = new Object();//新增锁对象

    public static void main(String[] args) {
        Thread t1 = new Thread(new PrintThreadName("A"), "A");
        Thread t2 = new Thread(new PrintThreadName("B"), "B");
        Thread t3 = new Thread(new PrintThreadName("C"), "C");
        t1.start();
        t2.start();
        t3.start();
    }

    static class PrintThreadName implements Runnable {
        private String threadName;

        public PrintThreadName(String threadName) {
            this.threadName = threadName;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                synchronized (lock) { // 使用独立锁对象
                    while (!current_thread.equals(threadName)) {
                        try {
                            lock.wait(); // 使用独立锁对象
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.print(threadName);
                    if (threadName.equals("A")) {
                        current_thread = "B";
                    } else if (threadName.equals("B")) {
                        current_thread = "C";
                    } else {
                        current_thread = "A";
                    }
                    lock.notifyAll(); // 使用独立锁对象
                }
            }
        }
    }
}

异常原因: wait()方法必须在持有对象的监视器锁时调用。 原代码中，current_thread作为锁对象，但在synchronized块内修改了current_thread的值。当线程调用wait()进入等待，current_thread的引用改变了。唤醒后，线程试图释放锁，但持有的锁对象已不是当前的current_thread，导致IllegalMonitorStateException。

解决方案: 使用一个独立的锁对象（例如代码中的lock对象）来控制线程同步，避免在持有锁的同时修改锁对象本身。 修改后的代码使用lock对象作为synchronized块的锁和wait()、notifyAll()方法的参数，从而避免了异常。 这保证了wait()方法始终在正确的锁对象上操作。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。