java - IllegalMonitorStateException 的原因

Question

我收到以下代码的非法状态异常：

synchronized (this) {
        try {
        Thread.currentThread().wait();
        notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
  }

我可以在“this”上同步将捕获调用该方法的对象上的监视器，并且由于我正在调用当前线程对象的等待，并且我真的没有锁定我得到 t 错误。请验证我的理论。

Answer 1

您在当前线程上调用等待，在此调用它。

this.wait();

但是你永远不会得到 a notifyAll，因为进入同步块的任何线程都无法到达该notofyAll方法。他们都会先等待。

我猜你希望一个线程等待另一个线程做一些工作。

这是线程之间的同步如何工作的简短示例

public class ThreadTest {

    public static void main(String[] args) throws InterruptedException {
        Object monitor = new Object();
        Thread t1 = new Thread(new R1(monitor));
        Thread t2 = new Thread(new R2(monitor));

        t1.start();
        t2.start();

        t2.join();
        t1.join();
    }

    public static class R1 implements Runnable {

        private Object monitor;

        public R1(Object monitor) {
            this.monitor = monitor;
        }

        public void run() {
            System.out.println("R1 entered run");
            synchronized (monitor) {
                try {
                    monitor.wait();
                    System.out.println("R1 got monitor back");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    public static class R2 implements Runnable {

        private Object monitor;

        public R2(Object monitor) {
            this.monitor = monitor;
        }

        public void run() {
            System.out.println("R2 entered run");
            synchronized (monitor) {
                System.out.println("R2 will sleep for 1 sec");
                try {
                    Thread.sleep(1000);
                    System.out
                            .println("R2 will notify all threads waiting for monitor");
                    monitor.notifyAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

输出是：

R1 entered run
R2 entered run
R2 will sleep for 1 sec
R2 will notify all threads waiting for monitor
R1 got monitor back

Answer 2

你已经获得了锁

这个（当前对象）

你打电话给`

等待（）

` 在当前线程上，这就是原因。

你应该在调用等待之前获取锁，通知 notifyAll

Answer 3

情况1

...
synchronized(this){
   this.wait();
}
...

案例2

...
synchronized(this){
   Thread.currentThread.wait();
}
...

案例 1 是明智的代码。它一直等到另一个线程调用notify[All]()“ this”对象。

案例 2 看起来很傻。this只有当前线程和“ ”是同一个对象，或者您已经在当前线程上锁定时，它才能执行。否则，你会得到IllegalMonitorStateException. 在 Thread 对象上同步是一件坏事，因为您无法确定还有什么可能在它们上同步。

顺便说一句，如果你想做的只是在程序中暂停一会儿，你应该sleep()，而不是wait()。

Answer 4

来自 Object 类 wait() 方法的 Java 文档：

IllegalMonitorStateException - 如果当前线程不是对象监视器的所有者。

在您的代码中，当前线程是监视器的所有者this并被wait调用Thread.currentThread。

替换Thread.currentThread().wait();为this.wait();