Java基础教程（141）线程同步之使用wait和notify：锁的暗号：深度解剖Java线程同步中的wait与notify艺术-优快云博客

深度分析Java线程同步之使用wait和notify

在Java多线程编程中，解决竞态条件（Race Condition）的首选工具往往是synchronized关键字或Lock锁。它们确保了临界区的互斥访问，即同一时刻只有一个线程可以执行。然而，互斥仅仅是协作的一半。当线程需要等待某个条件满足（例如，等待队列非空、资源可用）时，仅仅持有锁并循环检查（“忙等待”）是对CPU资源的极大浪费。这时，我们就需要更高级的线程间通信机制——wait()和notify()。

一、核心机制：对象监视器（Monitor）

每个Java对象都自带一个内置锁（Intrinsic Lock）和一个等待集合（Wait Set）。synchronized关键字操作的就是这个内置锁。而wait(), notify(), notifyAll()则是操作等待集合的方法，它们必须在已获得该对象锁的同步代码块或同步方法中调用，否则会抛出IllegalMonitorStateException异常。

二、方法深度解析

wait():

- 作用：让当前线程释放其持有的对象锁，并进入等待（阻塞）状态，同时将该线程移入该对象的等待集合中。
- 要点：它不是占用资源地等待，而是主动放弃锁，让其他线程有机会执行，从而改变它正在等待的条件。这是一个原子性的操作。

notify():

- 作用：随机唤醒在此对象监视器上等待的单个线程。被唤醒的线程会从等待集合中移除，并重新参与到CPU时间的竞争中去。注意，它并不释放锁，只有在当前同步代码块执行完毕释放锁后，被唤醒的线程才有机会去争夺锁并继续执行。
- notifyAll()：唤醒在此对象监视器上等待的所有线程。让它们全部去竞争锁。虽然最终只有一个能拿到锁，但这避免了notify()可能因唤醒不精准而导致的“线程饥饿”问题。

三、经典范式与示例：生产者-消费者模型

这是一个最能体现wait/notify价值的场景。生产者生产数据，消费者消费数据，它们共享一个固定大小的缓冲区。

核心代码范式：
在检查条件时，必须使用while循环，而不是if语句。这是因为被唤醒的线程需要再次确认条件是否真正满足，防止“虚假唤醒”（Spurious Wakeup）。

synchronized (lock) {
    while (/* 条件不满足 */) { // 必须用while！
        lock.wait();
    }
    // ... 执行条件满足后的操作
    // 操作完后，通常需要通知可能等待的另一方
    lock.notifyAll(); // 或 lock.notify();
}

示例代码：

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

public class ProducerConsumerExample {
    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) {
                // 1. 检查条件：如果缓冲区满了，就等待
                while (queue.size() == CAPACITY) {
                    System.out.println("缓冲区满，生产者等待...");
                    lock.wait();
                }
                // 2. 生产数据
                System.out.println("生产者生产: " + value);
                queue.offer(value++);
                // 3. 通知可能正在等待的消费者（现在非空了）
                lock.notifyAll();
                // 模拟生产耗时
                Thread.sleep(500);
            }
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (lock) {
                // 1. 检查条件：如果缓冲区空了，就等待
                while (queue.isEmpty()) {
                    System.out.println("缓冲区空，消费者等待...");
                    lock.wait();
                }
                // 2. 消费数据
                Integer value = queue.poll();
                System.out.println("消费者消费: " + value);
                // 3. 通知可能正在等待的生产者（现在不满啦）
                lock.notifyAll();
                // 模拟消费耗时
                Thread.sleep(1000);
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumerExample example = new ProducerConsumerExample();
        Thread producerThread = new Thread(() -> {
            try {
                example.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread consumerThread = new Thread(() -> {
            try {
                example.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        producerThread.start();
        consumerThread.start();
    }
}

运行结果（片段）:

生产者生产: 0
生产者生产: 1
...
缓冲区满，生产者等待...
消费者消费: 0
消费者消费: 1
...
缓冲区空，消费者等待...
生产者生产: 5
...

四、总结与最佳实践

wait/notify是Object的方法，sleep是Thread的方法，二者有本质区别。
永远在循环中调用wait()，以防范虚假唤醒。
优先使用notifyAll()，除非你能确保每次唤醒的都是最合适的那个线程，否则使用notify()可能导致某些线程永远不被唤醒。
明确锁对象，你调用的是哪个对象的wait()和notify()，操作的就是哪个对象的监视器。
对于更复杂的场景，Java并发包（java.util.concurrent）中的Condition、BlockingQueue等组件提供了更强大和灵活的线程协作工具，它们是wait/notify的现代替代品，但其思想内核一脉相承。