Java中的notify（）与notifyAll（）区别

• 一、notify()方法
• • 1.1 关键点
• 二、notifyAll()方法
• • 2.1 关键点
• 三、区别与选择
• • 3.1 区别
  • 3.2 选择
• 四、实例演示

一、notify()方法

notify()方法是Object类的一个方法，用于唤醒在此对象监视器上等待的单个线程。这里需要注意的是，notify()方法并不能指定唤醒哪个具体的线程，而是随机唤醒等待队列中的一个线程。因此，当只有一个线程在等待时，notify()方法才显得有用。

1.1 关键点

• 随机唤醒：唤醒在此对象监视器上等待的单个线程，但不保证是哪个线程。
• 单一性：在多个线程等待时，只能唤醒一个线程。
• 局限性：如果调用notify()时没有线程在等待，那么这个方法将不会有任何效果。

二、notifyAll()方法

与notify()方法不同，notifyAll()方法会唤醒在此对象监视器上等待的所有线程。这意味着，一旦调用notifyAll()，所有因调用此对象的wait()方法而阻塞的线程都将被唤醒，并有机会重新获得对象的锁。

2.1 关键点

• 全面唤醒：唤醒在此对象监视器上等待的所有线程。
• 竞争锁：被唤醒的线程需要重新竞争对象的锁，只有获得锁的线程才能继续执行。
• 确保性：确保至少有一个线程能继续运行，尤其是在多个线程等待时。

三、区别与选择

3.1 区别

• 唤醒对象：notify()唤醒一个线程，而notifyAll()唤醒所有线程。
• 适用场景：notify()适用于确切知道只有一个线程在等待的情况；而notifyAll()则适用于不确定有多少个线程在等待，或者希望所有等待的线程都能被唤醒并尝试继续执行的情况。

3.2 选择

• 当只有一个线程会等待某个条件，并且只需要唤醒这个线程时，使用notify()。
• 当不知道有多少个线程在等待，或者希望所有等待的线程都有机会被唤醒并尝试继续执行时，使用notifyAll()。

四、实例演示

假设有一个生产者-消费者模型，生产者线程生产产品后放入缓冲区，消费者线程从缓冲区中取出产品。

在这个模型中，如果只有一个消费者线程，可能使用notify()就足够了；但如果有多个消费者线程，那么使用notifyAll()将更为稳妥，因为它能确保所有等待的消费者线程都有机会被唤醒并尝试从缓冲区中取出产品。

下面是一个简单的生产者-消费者模型的Java实现，其中使用了notifyAll()来确保所有等待的消费者都能被唤醒：

import java.util.LinkedList; import java.util.Queue;  public class ProducerConsumerExample {     // 使用一个队列作为缓冲区       private final Queue buffer = new LinkedList<>();     // 缓冲区容量       private final int capacity = 10;     // 对象锁       private final Object lock = new Object();      public static void main(String[] args) {         ProducerConsumerExample example = new ProducerConsumerExample();          // 创建并启动生产者线程           Thread producer = new Thread(() -> {             for (int i = 0; i < 20; i++) {                 try {                     example.produce(i);                 } catch (InterruptedException e) {                     throw new RuntimeException(e);                 }             }         });          // 创建并启动消费者线程           Thread consumer1 = new Thread(() -> {             for (int i = 0; i < 10; i++) {                 try {                     example.consume();                 } catch (InterruptedException e) {                     throw new RuntimeException(e);                 }             }         });          Thread consumer2 = new Thread(() -> {             for (int i = 0; i < 10; i++) {                 try {                     example.consume();                 } catch (InterruptedException e) {                     throw new RuntimeException(e);                 }             }         });          producer.start();         consumer1.start();         consumer2.start();     }      // 生产者方法       public void produce(int product) throws InterruptedException {         synchronized (lock) {             while (buffer.size() == capacity) {                 // 缓冲区满，生产者等待                   lock.wait();             }             buffer.add(product);             System.out.println("Produced: " + product);             // 唤醒所有等待的消费者               lock.notifyAll();         }     }      // 消费者方法       public void consume() throws InterruptedException {         synchronized (lock) {             while (buffer.isEmpty()) {                 // 缓冲区空，消费者等待                   lock.wait();             }             Integer item = buffer.poll();             System.out.println("Consumed: " + item);             // 唤醒所有等待的生产者或消费者（虽然这里主要是生产者可能等待）               lock.notifyAll();         }     } }