多线程同步wait()异常：IllegalMonitorStateException终极解决方案

本文深入分析了多线程编程中使用`wait()`方法导致`IllegalMonitorStateException`异常的原因及解决方法。文章通过一个控制三个线程打印顺序的代码示例，展现了错误使用`volatile`字符串变量作为锁对象引发的异常。核心问题在于`wait()`方法必须在持有锁对象的线程上调用，而代码中锁对象`CURRENT_THREAD`在`wait()`调用后被修改，导致线程重新获取锁时持有不同的对象，最终抛出异常。文章最后给出了解决方案：使用独立的锁对象来避免锁对象不一致，从而有效解决`IllegalMonitorStateException`异常，确保线程按预期顺序执行。 关键词：多线程，同步，wait(), IllegalMonitorStateException, Java, 并发编程

深入探讨多线程同步与wait()方法引发的IllegalMonitorStateException异常

本文分析一段旨在控制三个线程打印顺序的代码，并详细解释其中出现的IllegalMonitorStateException异常。目标是让线程A、B、C依次打印ID，循环五次，打印顺序为ABCA…

代码示例：

package 并发编程.work2;

public class Test {
    private static volatile String CURRENT_THREAD = "A";

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

    static class PrintThreadName implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                synchronized (CURRENT_THREAD) {
                    if (!Thread.currentThread().getName().equals(CURRENT_THREAD)) {
                        try {
                            CURRENT_THREAD.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName());
                    CURRENT_THREAD = getNextThread(CURRENT_THREAD);
                    CURRENT_THREAD.notifyAll();
                }
            }
        }

        private String getNextThread(String current) {
            switch (current) {
                case "A":
                    return "B";
                case "B":
                    return "C";
                case "C":
                    return "A";
                default:
                    return "A";
            }
        }
    }
}

异常原因分析：错误的锁对象使用

代码的核心问题在于CURRENT_THREAD变量的用法。代码尝试使用一个volatile修饰的字符串变量作为锁对象，并在每个线程打印完毕后修改其值，以控制下一个线程的执行。这种方法存在严重缺陷。

wait()方法必须在持有锁对象的线程上调用。线程调用wait()后，释放锁并进入等待状态。其他线程调用notify()或notifyAll()后，该线程才能重新竞争锁并继续执行。问题在于，线程调用CURRENT_THREAD.wait()进入等待状态后，CURRENT_THREAD的值被修改了。线程再次获得锁时，持有的锁对象已不再是它等待时持有的锁对象。如果线程尝试在新的CURRENT_THREAD对象上释放锁（隐含在wait()之后），就会抛出IllegalMonitorStateException异常，因为该线程并不持有新CURRENT_THREAD对象的锁。

解决方案：使用独立锁对象

解决方法是使用一个独立的锁对象来实现线程同步，避免在持有锁对象的同时修改锁对象本身。这确保wait()和notifyAll()方法在同一个锁对象上操作，避免锁对象不一致，从而避免IllegalMonitorStateException异常。 一个简单的改进方法是引入一个Object类型的锁：

private static final Object lock = new Object(); // 使用独立的锁对象

然后在synchronized块中使用lock对象：

synchronized (lock) {
    // ... your code here ...
}

通过这种修改，可以有效地避免IllegalMonitorStateException异常，并确保线程按照预期顺序执行。

终于介绍完啦！小伙伴们，这篇关于《多线程同步wait()异常：IllegalMonitorStateException终极解决方案》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布文章相关知识，快来关注吧！