Java wait() 不会被 notify() 唤醒

Question

你好，我已经调试了一整天的代码，但我就是看不出哪里有问题。

我在主线程上使用 SerialPortEventListener，在工作线程中我有一个客户端套接字与服务器通信。 由于在这个工作线程到达return 之后，我仍然需要在主线程中完成一些总结工作，我想创建一个在主线程中等待的“伪线程”，直到它从监听器 onEvent 方法得到通知。

但是这个伪线程似乎永远在等待。

我检查了锁定线程pseudoThread，它们在 Runnable 和 Listener 类中应该具有相同的对象 ID。

显示“PseudoThread waiting”，但从未显示 PseudoThread awake。

控制台输出显示： 伪线程等待 .. .. 错误通知伪线程。

PS 如果我在 Main 类中使用 public final Object lock = new Object(); 创建一个锁并将所有 main.pseudoThread 替换为 main.lock，我会得到 java.lang.IllegalMonitorStateException。

private class Pseudo implements Runnable{
    Main main;
    public Pseudo(Main main) {
        this.main = main;
    }

    @Override
    public void run() {
        synchronized(main.pseudoThread){
            try {
                System.out.println("PseudoThread waiting");
                main.pseudoThread.wait();
                System.out.println("PseudoThread awake");
            } catch (InterruptedException e) {
                e.printStackTrace();
                return;
            }
        }

    }

}

在主方法中：

public static void main(String[] args) {
    Main main = new Main();
    main.initArduino();
    //more code. including starting the working thread
    main.pseudoThread = new Thread(main.new Pseudo(main));
        main.pseudoThread.start();
        try {
            main.pseudoThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
}
private void initArduino() {
    arduino = new Arduino(this);
    if(!arduino.initialize())
        System.exit(1);
}

在监听器类中（也在主线程中运行）

//class constructor;
public Arduino(Main Main){
    this.main = Main;
}
//listening method
public void serialEvent(SerialPortEvent oEvent){
    //some code to interract with working thread.
    record();

}
private void record(){
        synchronized(main.pseudoThread){
            main.pseudoThread.notify();
            System.out.println("notified pseudothread.");
        }
}

Answer 1

如果不深入研究可能实际发生的事情，我可以看出您对 wait()/notify() 的使用都是错误的。您可能正在经历“丢失的通知”。如果在调用时没有线程等待它，则 notify() 函数会执行 nothing。如果您的 serialEvent() 函数在其他线程调用 wait() 之前调用 notify()，则通知将丢失。

考虑这个例子：

class WaitNotify() {
    private final Object lock = new Object();
    private long head = 0;
    private long tail = 0;

    public void consumer() {
        synchronized (lock) {
            while(head == tail) {
                lock.wait();
            }
            doSomething();
            count head += 1;
        }
    }

    public void producer() {
        synchronized (lock) {
            tail += 1;
            lock.notify();
        }
    }
}

要点是：

(1) consumer() 函数等待数据之间的某种关系变为真：这里，它等待head != tail。

(2) consumer() 函数循环等待。这有两个原因： (a) 许多程序有不止一个消费者线程。如果消费者 A 从 wait() 中醒来，则不能保证消费者 B 尚未声明他们都在等待的任何东西。并且 (b) Java 语言规范允许 foo.wait() 有时返回，即使 foo.notify() 没有被调用。这就是所谓的“虚假唤醒”。允许虚假唤醒（只要它们不经常发生）可以更轻松地实现 JVM。

(3) 锁对象是程序用来保护条件所依赖的变量的相同锁。如果这个例子是一个更大的程序的一部分，你会看到 synchronized(lock) 围绕着 head 和 tail 的每次使用，无论同步代码是 wait()ing 还是 notify()ing。

如果您自己的代码在调用 wait() 和 notify() 时遵守上述所有三个规则，那么您的程序将更有可能按照您期望的方式运行。

Answer 2

正如 james 所建议的，它可能会丢失通知情况，或者可能是......两个线程 1-您的主线程和 2-伪线程正在等待同一个线程实例锁 (main.pseudoThread)(Main线程通过调用join方法等待同一个锁）。 现在您正在使用 notify 从 join 方法中唤醒主线程，而不是那个 等待你的伪。要检查第二种情况，请尝试在记录中调用 notifyall 这将 确认第二种情况或将排除这种可能性。

无论如何，请重构您的代码，不要在 Thread 实例上使用同步，这是不好的做法。去 ReentrantLock 或 CoundDownLatch 吧。

Answer 3

notify 和 wait 的用法似乎不正确。方法名称 notify 可能有点误导，因为它不是用于通用“通知”。这些方法用于控制同步块的执行。等待将允许其他线程在当前线程暂停时与同一对象同步。基本上，当某些资源不可用且执行无法继续时使用。另一方面，在通知线程完成其同步块后，通知将唤醒一个等待线程从等待中唤醒。同一对象的同步块中只能有一个线程同时存在。

如果这个想法只是保持主程序运行直到收到通知，那么信号量会更合适。像这样的。

public void run() {
   System.out.println("PseudoThread waiting");
   main.semaphore.acquireUninterruptibly();
   System.out.println("PseudoThread awake");
}
//...
private void record(){
   main.semaphore.release();
}
//...
public static void main(String[] args) {
   main.semaphore = new Semaphore(0);
   //...
}