JAVA使用WaitNotify信号丢失与虚假唤醒问题的底层机制 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JAVA并发中的Wait/Notify机制：信号丢失与虚假唤醒的深度剖析

大家好，今天我们来深入探讨Java并发编程中一个非常重要的机制：wait()和notify()/notifyAll()。这组方法是实现线程间协作与同步的关键，但如果不理解其底层机制，很容易遇到令人困惑的信号丢失和虚假唤醒问题。我们将从底层原理出发，剖析这些问题的根源，并提供相应的解决方案。

1. `wait()`/`notify()`/`notifyAll()`的基本原理

wait()、notify()和notifyAll()方法是java.lang.Object类提供的，这意味着任何Java对象都可以作为锁（monitor）使用。这三个方法必须在synchronized代码块或方法中调用，且必须在持有该对象锁的线程中调用。

wait(): 当一个线程调用了某个对象的wait()方法，它会：
- 释放该对象的锁。
- 进入该对象的等待集合（wait set），并阻塞，直到被其他线程唤醒。
- 当被唤醒（通过notify()或notifyAll()）后，该线程会尝试重新获取该对象的锁。如果获取成功，线程会从wait()方法返回，并继续执行；否则，线程会继续阻塞，直到获取到锁。
notify(): 当一个线程调用了某个对象的notify()方法，它会：
- 从该对象的等待集合中随机选择一个线程。
- 唤醒该线程，使其从阻塞状态变为可运行状态。被唤醒的线程会尝试重新获取该对象的锁。
notifyAll(): 当一个线程调用了某个对象的notifyAll()方法，它会：
- 唤醒该对象等待集合中的所有线程。所有被唤醒的线程都会尝试重新获取该对象的锁。

为什么要持有锁才能调用wait()/notify()/notifyAll()?

这是为了保证线程间的状态同步和避免竞态条件。

状态同步: wait()方法的目的是让线程等待某个条件成立。这个条件通常是由其他线程修改某个共享变量的值来触发的。为了保证线程安全地检查和修改共享变量，必须持有锁。
避免竞态条件: 如果没有锁，可能出现以下情况：线程A检查到条件不满足，准备调用wait()方法，但在调用wait()之前，线程B修改了条件，并调用了notify()。此时，线程A调用wait()后，可能会永远等待，因为notify()已经发生过了。持有锁可以保证检查条件和调用wait()的原子性。

一个简单的例子:

public class WaitNotifyExample {

    private static final Object lock = new Object();
    private static boolean condition = false;

    public static void main(String[] args) throws InterruptedException {

        Thread waiter = new Thread(() -> {
            synchronized (lock) {
                while (!condition) { // 关键：循环检查条件
                    try {
                        System.out.println("Waiter: Waiting for condition to be true.");
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
                System.out.println("Waiter: Condition is true. Proceeding.");
            }
        });

        Thread notifier = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Notifier: Setting condition to true.");
                condition = true;
                lock.notify();
                System.out.println("Notifier: Notified waiter.");
            }
        });

        waiter.start();
        Thread.sleep(100); // 确保waiter先进入等待状态
        notifier.start();

        waiter.join();
        notifier.join();

        System.out.println("Main: Done.");
    }
}

在这个例子中，waiter线程等待condition变为true。notifier线程将condition设置为true，并调用notify()唤醒waiter线程。关键是waiter线程使用while循环来检查条件，这是解决虚假唤醒问题的关键。

2. 信号丢失 (Lost Signal) 问题

信号丢失指的是一个线程在另一个线程调用 notify()/notifyAll() 之前调用了 wait()，导致 notify()/notifyAll() 的信号“丢失”，等待线程永远无法被唤醒。

产生信号丢失的场景:

notify() 在 wait() 之前: 线程 A 尝试获取锁，发现条件不满足，但在调用 wait() 之前，线程 B 已经设置了条件并调用了 notify()。当线程 A 最终调用 wait() 时，它会永远等待，因为 notify() 已经发生过了。
多个线程竞争: 多个线程都在等待同一个条件。当条件满足时，一个线程被唤醒并处理了条件，但在其他线程被唤醒之前，条件又恢复到不满足的状态。剩余的线程可能会进入永久等待状态。

代码示例 (信号丢失):

public class LostSignalExample {

    private static final Object lock = new Object();
    private static boolean messageReceived = false;

    public static void main(String[] args) throws InterruptedException {

        Thread receiver = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Receiver: Waiting for message.");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    return;
                }
                System.out.println("Receiver: Message received.");
            }
        });

        Thread sender = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Sender: Sending message.");
                messageReceived = true;
                lock.notify();
                System.out.println("Sender: Message sent.");
            }
        });

        // 模拟notify先于wait发生
        sender.start();
        Thread.sleep(10); // 模拟sender先执行
        receiver.start();

        receiver.join();
        sender.join();

        System.out.println("Main: Done.");
    }
}

在这个例子中，如果 sender 线程在 receiver 线程调用 wait() 之前执行，receiver 线程可能会永远等待。虽然 sender 发送了消息并调用了 notify()，但是 receiver 线程当时并不在等待状态，所以错过了这个信号。

如何避免信号丢失?

避免信号丢失的关键在于使用循环检查条件，并且确保 wait() 方法在条件不满足时才被调用。

修改后的代码示例 (避免信号丢失):

public class AvoidLostSignalExample {

    private static final Object lock = new Object();
    private static boolean messageReceived = false;

    public static void main(String[] args) throws InterruptedException {

        Thread receiver = new Thread(() -> {
            synchronized (lock) {
                while (!messageReceived) { // 循环检查条件
                    System.out.println("Receiver: Waiting for message.");
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
                System.out.println("Receiver: Message received.");
            }
        });

        Thread sender = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Sender: Sending message.");
                messageReceived = true;
                lock.notify();
                System.out.println("Sender: Message sent.");
            }
        });

        // 模拟notify先于wait发生
        sender.start();
        Thread.sleep(10); // 模拟sender先执行
        receiver.start();

        receiver.join();
        sender.join();

        System.out.println("Main: Done.");
    }
}

在这个修改后的例子中，receiver 线程使用 while (!messageReceived) 循环来检查消息是否已经收到。即使 sender 线程在 receiver 线程调用 wait() 之前发送了消息，receiver 线程仍然会检查条件，并不会进入永久等待状态。

3. 虚假唤醒 (Spurious Wakeup) 问题

虚假唤醒指的是线程在没有被 notify()/notifyAll() 显式唤醒的情况下，从 wait() 方法中返回。这是由于 JVM 的实现或者底层操作系统的调度机制导致的，并非bug，而是一种规范。

虚假唤醒的根本原因:

wait() 方法的实现依赖于底层操作系统的线程调度机制。在某些情况下，操作系统可能会在没有收到显式唤醒信号的情况下，唤醒一个等待中的线程。

如何处理虚假唤醒?

处理虚假唤醒的唯一方法就是使用循环检查条件。

代码示例 (处理虚假唤醒):

public class SpuriousWakeupExample {

    private static final Object lock = new Object();
    private static boolean condition = false;

    public static void main(String[] args) throws InterruptedException {

        Thread waiter = new Thread(() -> {
            synchronized (lock) {
                while (!condition) { // 循环检查条件
                    try {
                        System.out.println("Waiter: Waiting for condition to be true.");
                        lock.wait();
                        System.out.println("Waiter: Woke up, checking condition again."); // 即使被唤醒，也要重新检查
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }
                System.out.println("Waiter: Condition is true. Proceeding.");
            }
        });

        Thread notifier = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Notifier: Setting condition to true.");
                condition = true;
                lock.notifyAll(); // 使用 notifyAll 更安全
                System.out.println("Notifier: Notified waiter.");
            }
        });

        waiter.start();
        Thread.sleep(100); // 确保waiter先进入等待状态
        notifier.start();

        waiter.join();
        notifier.join();

        System.out.println("Main: Done.");
    }
}

在这个例子中，waiter 线程使用 while (!condition) 循环来检查条件。即使发生了虚假唤醒，线程也会重新检查条件，如果条件仍然不满足，它会继续等待。另外，notifier线程使用notifyAll()，在多线程环境下更安全。

为什么循环检查条件是必要的?

循环检查条件可以确保线程在以下情况下都能正确地处理：

信号丢失: 如果 notify() 在 wait() 之前发生，线程仍然会检查条件。
虚假唤醒: 如果线程被虚假唤醒，它会重新检查条件。
多个线程竞争: 如果多个线程都在等待同一个条件，当一个线程处理了条件后，其他线程会被唤醒并重新检查条件，如果条件不再满足，它们会继续等待。

4. `notify()` vs `notifyAll()` 的选择

notify(): 随机唤醒等待集合中的一个线程。适用于只有一个线程需要被唤醒的情况，可以提高效率。但是，如果唤醒了错误的线程，可能会导致死锁或者其他问题。
notifyAll(): 唤醒等待集合中的所有线程。适用于多个线程都需要被唤醒的情况，可以避免唤醒错误的线程。但是，会降低效率，因为所有线程都会尝试重新获取锁。

选择原则:

如果只有一个线程需要被唤醒，且可以准确地确定需要唤醒哪个线程，可以使用 notify()。
在其他情况下，都应该使用 notifyAll()，以确保线程安全。

尤其是在以下情况，必须使用notifyAll():

多个线程等待不同的条件，但共享同一个锁。
无法准确地确定需要唤醒哪个线程。
为了避免死锁或者其他并发问题。

表格对比:

特性	`notify()`	`notifyAll()`
唤醒线程数量	1	所有等待线程
效率	较高，如果唤醒正确的线程	较低，所有线程都会尝试获取锁
安全性	较低，可能唤醒错误的线程，导致死锁或问题	较高，避免唤醒错误的线程，更安全可靠
适用场景	只有一个线程需要被唤醒，且能准确确定	多个线程需要被唤醒，或无法准确确定唤醒哪个

5. 最佳实践

始终在 synchronized 代码块或方法中调用 wait()/notify()/notifyAll()。
始终使用循环检查条件，避免信号丢失和虚假唤醒。
优先使用 notifyAll()，除非可以准确地确定需要唤醒哪个线程。
仔细分析并发场景，选择合适的同步机制。
考虑使用更高级的并发工具，例如 java.util.concurrent 包中的 Lock、Condition、BlockingQueue 等，它们提供了更灵活和强大的并发控制能力。

6. 一个更复杂的例子：生产者-消费者模型

import java.util.LinkedList;
import java.util.Queue;

public class ProducerConsumer {

    private static final int CAPACITY = 5;
    private final Queue<Integer> queue = new LinkedList<>();
    private final Object lock = new Object();

    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (lock) {
                while (queue.size() == CAPACITY) {
                    System.out.println("Producer: Queue is full, waiting...");
                    lock.wait();
                }

                System.out.println("Producer: Producing value " + value);
                queue.offer(value++);
                lock.notifyAll(); // 唤醒所有等待的消费者

                Thread.sleep(100); // 模拟生产耗时
            }
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (lock) {
                while (queue.isEmpty()) {
                    System.out.println("Consumer: Queue is empty, waiting...");
                    lock.wait();
                }

                int value = queue.poll();
                System.out.println("Consumer: Consuming value " + value);
                lock.notifyAll(); // 唤醒所有等待的生产者

                Thread.sleep(200); // 模拟消费耗时
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        Thread producerThread = new Thread(() -> {
            try {
                pc.produce();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                pc.consume();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producerThread.start();
        consumerThread.start();
    }
}

在这个生产者-消费者模型中，生产者线程负责向队列中添加元素，消费者线程负责从队列中移除元素。队列有一个最大容量 CAPACITY。

当队列满时，生产者线程会调用 wait() 方法进入等待状态。
当队列为空时，消费者线程会调用 wait() 方法进入等待状态。
当生产者线程向队列中添加元素后，会调用 notifyAll() 方法唤醒所有等待的消费者线程。
当消费者线程从队列中移除元素后，会调用 notifyAll() 方法唤醒所有等待的生产者线程。

这个例子展示了如何使用 wait() 和 notifyAll() 来实现线程间的协作和同步，以及如何使用循环检查条件来避免信号丢失和虚假唤醒。 notifyAll()的使用是必须的，因为可能有多个生产者和消费者线程同时等待。

最后要记住的关键点

wait() 和 notify()/notifyAll() 是Java并发编程的基础，但理解其底层机制和潜在问题至关重要。始终使用循环检查条件，并根据实际情况选择 notify() 或 notifyAll()，才能编写出安全、可靠的并发程序。理解了这些，并发编程的道路将会更加平坦。

JAVA并发中的Wait/Notify机制：信号丢失与虚假唤醒的深度剖析

1. wait()/notify()/notifyAll()的基本原理