Question

这是我的第一篇文章，如果我做错了，请抱歉。我试图理解Java中的线程是如何工作的，特别是同步，这就是为什么我创建了一段应该打印1,2,3,4,5,6（在一个线程中）然后然后打印的代码的原因。第二个线程等待第一个完成，然后打印6,5,4,3,2,1但它只执行前6个步骤并告诉我在线程t2中有等待方法的监视器问题和一个问题通知所有线程t1。也许我对一个对象的同步一无所知。这是我的代码：

public class anObject extends Thread {

long value;
String name;

public anObject(long value, String name) {
    this.value = value;
    this.name = name;
}

public synchronized void add() {
    this.value++;
}

public synchronized void sub() {
    this.value--;
}

public static void main(String[] args) {

    anObject il = new anObject(0, "Bob");

    synchronized (il) {

        Thread t1 = new Thread(il) {
            public void run() {
                while (il.value > 0) {
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                for (int i = 0; i < 6; i++) {
                    il.add();
                    System.out.println(il.value);
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                il.notifyAll();
            }
        };

        Thread t2 = new Thread(il) {
            public void run() {
                while (il.value < 6) {
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                for (int j = 0; j < 6; j++) {
                    il.sub();
                    System.out.println(il.value);
                    try {
                        sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                il.notifyAll();
            }
        };

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

    }
}

}

这就是终端中出现的内容：

Exception in thread "Thread-2" 1
java.lang.IllegalMonitorStateException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Unknown Source)
at anObject$2.run(anObject.java:53)
2
3
4
5
6
Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
at java.lang.Object.notifyAll(Native Method)
at anObject$1.run(anObject.java:45)

非常感谢你的帮助！问候

Answer 1

你在做什么

synchronized (il)

只是从主线程中抓取一个对象的监视器。但是你正在初始化两个新线程，并尝试从这些最近初始化的线程和然后启动线程的上下文中调用wait()方法。 IllegalMonitorStateException的主要思想是，您尝试调用一个方法，该方法使用对象锁定的上下文，而不先于获取此对象的锁定。你能做些什么来快速修复它只是为了改变

while (il.value > 0) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

on

while (il.value > 0) {
                try {
                    synchronized(this) {
                        this.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

并在第二个代码块中进行相同的更改。但要真正做到正确，我建议你转向描述多线程概念的一些强大的来源。我猜想Oracle的基本java教程会很好。

Answer 2

在对象中定义

等待，这就是您获得此例外的原因。

我更喜欢专用的 lock ，以避免出现不可预测的监视器异常：

private final Object lock = new Object();


private static final class Lock { }
private final Object lock = new Lock();

对于notify或notifyAll对象，您需要使用synchronized语句持有锁。此外，您应该定义一个循环来检查唤醒条件。

synchronized (lock) {
    while (!isWakeupNeeded()) {
        lock.wait();
    }
}

通知：

synchronized (lock) {
    makeWakeupNeeded();
    lock.notifyAll();
}

Java Thread Class：java.lang.IllegalMonitorStateException

2 个答案: