多线程（20）wait、notify和notifyAll的用法

痛定思痛。 2024-04-24 23:09 4阅读 0赞

在Java中，`wait()`, `notify()`, 和 `notifyAll()` 是属于 `Object` 类的方法，这些方法用来协调多个线程对共享对象的访问。它们通常与同步代码块 (`synchronized` 块) 结合使用，以实现线程之间的通信。

#### `wait()` ####

`wait()` 方法使当前线程暂停执行并释放对象的锁（该线程必须拥有对象的锁），直到其他线程调用同一个对象上的 `notify()` 或者 `notifyAll()` 方法。调用 `wait()` 后，当前线程进入等待状态直到以下几种情况之一发生：

*  另一个线程调用了对象的 `notify()` 方法，并且恰好选择了当前线程进行唤醒。
 *  另一个线程调用了对象的 `notifyAll()` 方法。
 *  等待的线程被中断（即在等待状态的线程上调用了 `interrupt()` 方法）。

#### `notify()` ####

`notify()` 方法唤醒在此对象的监视器上等待的单个线程（如果存在）。如果有多个线程都在该对象上等待，则选择其中一个线程进行唤醒。选择是任意的，并由具体的JVM实现决定。

#### `notifyAll()` ####

`notifyAll()` 方法唤醒在此对象的监视器上等待的所有线程。所有被唤醒的线程将竞争对象锁。唤醒并不意味着立即得到执行，线程需要重新获得对象锁才能继续执行。

#### 示例代码 ####

public class WaitNotifyExample {
        
        public static void main(String[] args) {
        
            final SharedResource sharedResource = new SharedResource();
    
            Thread producerThread = new Thread(() -> {
        
                try {
        
                    for (int i = 0; i < 5; i++) {
        
                        sharedResource.produce();
                    }
                } catch (InterruptedException e) {
        
                    Thread.currentThread().interrupt();
                }
            });
    
            Thread consumerThread = new Thread(() -> {
        
                try {
        
                    for (int i = 0; i < 5; i++) {
        
                        sharedResource.consume();
                    }
                } catch (InterruptedException e) {
        
                    Thread.currentThread().interrupt();
                }
            });
    
            producerThread.start();
            consumerThread.start();
        }
    
        public static class SharedResource {
        
            private boolean isAvailable = false;
    
            public synchronized void produce() throws InterruptedException {
        
                while (isAvailable) {
        
                    // 生产者线程等待，直到资源被消费
                    wait();
                }
                System.out.println("Produced the resource.");
                isAvailable = true;
                // 唤醒一个等待的消费者线程
                notify();
            }
    
            public synchronized void consume() throws InterruptedException {
        
                while (!isAvailable) {
        
                    // 消费者线程等待，直到资源被生产
                    wait();
                }
                System.out.println("Consumed the resource.");
                isAvailable = false;
                // 唤醒一个等待的生产者线程
                notify();
            }
        }
    }

在这个例子中，我们定义了一个名为 `SharedResource` 的类。它有两个方法：`produce()` 和 `consume()`。这两个方法都是同步的，意味着它们在执行时会锁定当前对象。

*  在 `produce()` 方法中，如果 `isAvailable` 是 `true`（表示资源已经被生产出来了），生产者线程会调用 `wait()` 并释放锁，进入等待状态。直到消费者线程消费了资源并调用 `notify()` 唤醒一个等待的线程。
 *  在 `consume()` 方法中，如果 `isAvailable` 是 `false`（表示资源尚未准备好被消费），消费者线程会调用 `wait()` 并释放锁，同样进入等待状态。直到生产者线程生产了资源并调用 `notify()` 唤醒一个等待的线程。

**注意**：`wait()` 和 `notify()` 必须在同步代码块或方法中调用，因为它们需要对象的监视器，而对象监视器只能通过进入同步代码块或方法获得。

这个例子中没有使用 `notifyAll()`，因为只有生产者和消费者两个角色，并且它们交替执行。如果有多个生产者和消费者，可能会考虑使用 `notifyAll()` 来唤醒所有等待的线程，然后它们各自检查条件是否满足，并相应地继续执行或回到等待状态。