编辑“︁Java Notifyall方法”︁

<big>'''Java notifyAll方法'''</big>

== 介绍 ==

在Java多线程编程中，`notifyAll()`是`Object`类的一个方法，用于唤醒所有正在等待该对象监视器（monitor）的线程。与`notify()`不同，`notify()`仅随机唤醒一个等待线程，而`notifyAll()`会唤醒所有等待线程，让它们竞争获取对象锁。

`notifyAll()`通常与`wait()`方法配合使用，实现线程间的协调。它适用于多线程共享资源时，需要通知多个等待线程的场景，例如生产者-消费者问题或线程池管理。

== 语法 ==

```java
public final void notifyAll()
```

== 工作原理 ==

1. 当线程调用`notifyAll()`时，会释放当前持有的对象锁。
2. 所有因调用`wait()`而进入等待状态的线程会被唤醒，并尝试重新获取对象锁。
3. 这些线程会从`wait()`调用处继续执行。

<mermaid>
graph TD
    A[线程调用notifyAll()] --> B[释放对象锁]
    B --> C[唤醒所有等待线程]
    C --> D[线程竞争锁]
    D --> E[一个线程获取锁并继续执行]
</mermaid>

== 代码示例 ==

以下是一个生产者-消费者模型的示例，展示`notifyAll()`的用法：

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

public class ProducerConsumerExample {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int CAPACITY = 5;

    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                // 如果队列已满，生产者等待
                while (queue.size() == CAPACITY) {
                    wait();
                }
                System.out.println("生产者生产: " + value);
                queue.add(value++);
                // 通知所有等待的消费者
                notifyAll();
                Thread.sleep(1000);
            }
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                // 如果队列为空，消费者等待
                while (queue.isEmpty()) {
                    wait();
                }
                int value = queue.poll();
                System.out.println("消费者消费: " + value);
                // 通知所有等待的生产者
                notifyAll();
                Thread.sleep(1000);
            }
        }
    }

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

=== 输出示例 ===
```
生产者生产: 0
生产者生产: 1
生产者生产: 2
生产者生产: 3
生产者生产: 4
消费者消费: 0
生产者生产: 5
消费者消费: 1
...
```

== 关键点说明 ==

1. `wait()`和`notifyAll()`必须在`synchronized`块内调用，否则会抛出`IllegalMonitorStateException`。
2. 使用`while`循环检查条件（如`queue.size() == CAPACITY`），而不是`if`语句，以避免虚假唤醒（spurious wakeup）。
3. `notifyAll()`会唤醒所有等待线程，但只有一个线程能获取锁并执行，其他线程会继续等待。

== 实际应用场景 ==

1. '''线程池管理'''：当任务队列为空时，工作线程会等待。当新任务到达时，主线程调用`notifyAll()`唤醒所有工作线程。
2. '''数据库连接池'''：当所有连接被占用时，请求线程等待。当连接释放时，调用`notifyAll()`唤醒等待线程。
3. '''事件驱动系统'''：多个线程等待某个事件发生，事件触发后调用`notifyAll()`通知所有监听线程。

== 与notify()的区别 ==

| 特性               | notify()                     | notifyAll()                  |
|--------------------|------------------------------|------------------------------|
| 唤醒线程数量       | 1个                          | 所有等待线程                 |
| 适用场景           | 单消费者或明确知道只需唤醒1个 | 多消费者或不确定唤醒数量时   |
| 性能影响           | 较低                         | 较高（可能引起不必要的竞争） |

== 数学表示 ==

假设有<math>n</math>个线程在等待，`notifyAll()`的唤醒效果可以表示为：

<math>
\text{notifyAll}() \Rightarrow \{ T_1, T_2, \ldots, T_n \} \text{ 进入就绪状态}
</math>

而`notify()`的效果是：

<math>
\text{notify}() \Rightarrow \{ T_k \mid k \in [1, n] \} \text{ 进入就绪状态}
</math>

== 注意事项 ==

1. 过度使用`notifyAll()`可能导致性能问题，因为所有等待线程会被唤醒并竞争锁。
2. 确保在正确的条件下调用`notifyAll()`，否则可能导致死锁或资源浪费。
3. 在Java 5+中，考虑使用`java.util.concurrent`包中的高级同步工具（如`Condition`），它们提供了更灵活的线程通知机制。

== 总结 ==

`notifyAll()`是Java多线程编程中的重要工具，用于协调多个线程的执行。理解其工作原理和适用场景，可以帮助开发者编写更高效、更安全的并发程序。在实际开发中，应根据具体需求选择`notify()`或`notifyAll()`，并始终结合`wait()`在循环中使用。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java多线程]]