章节 31 | Guarded Suspension模式：等待唤醒机制的规范实现

在Java并发编程的广阔领域中，等待唤醒机制是实现线程间协作与同步的关键技术之一。它允许一个或多个线程在某些条件未满足时暂停执行（等待），并在这些条件被其他线程改变（唤醒）后继续执行。这种机制对于构建高效、可靠的并发应用至关重要。本章将深入探讨Guarded Suspension（受保护挂起）模式，它是等待唤醒机制的一种规范化实现方式，旨在提升代码的可读性、可维护性和效率。

31.1 引言

在Java中，wait() 和 notify()/notifyAll() 方法是实现等待唤醒机制的原生API，它们定义在java.lang.Object类中，因此所有Java对象都可以作为同步锁使用这些机制。然而，直接使用这些方法容易出错，因为它们必须被包裹在同步块或同步方法中，且调用时存在多种潜在的陷阱，如条件竞争、虚假唤醒等。Guarded Suspension模式通过封装这些原生API，提供了一种更为安全和易于理解的实现方式。

31.2 Guarded Suspension模式概述

Guarded Suspension模式的核心思想是：在循环中检查某个条件（称为“守卫条件”），如果条件不满足，则调用等待方法挂起当前线程；当条件由其他线程改变后，通过唤醒方法唤醒等待的线程，并重新检查条件。这种模式的关键在于确保在条件满足之前，线程保持挂起状态，同时处理虚假唤醒的情况。

关键组件：

1. 锁对象：作为同步的基础，通常是共享资源或专门用于同步的某个对象。
2. 守卫条件：线程等待或继续执行所依赖的条件。
3. 等待方法：当守卫条件不满足时，线程会调用此方法挂起自己。
4. 唤醒方法：当守卫条件可能已改变时，其他线程会调用此方法唤醒等待的线程。

31.3 示例实现

假设我们有一个简单的生产者-消费者问题，其中有一个固定大小的缓冲区用于存储产品。生产者线程生成产品并尝试放入缓冲区，如果缓冲区已满，则生产者必须等待；消费者线程从缓冲区取出产品，如果缓冲区为空，则消费者必须等待。

步骤1：定义共享资源及守卫条件

public class BoundedBuffer<T> {
    private final Object lock = new Object();
    private final T[] buffer;
    private int count = 0;
    private int putPos = 0;
    private int takePos = 0;
    public BoundedBuffer(int capacity) {
        buffer = (T[]) new Object[capacity];
    }
    // 守卫条件：缓冲区未满
    private boolean notFull() {
        return count < buffer.length;
    }
    // 守卫条件：缓冲区非空
    private boolean notEmpty() {
        return count > 0;
    }
    // ...
}

步骤2：实现等待和唤醒逻辑

    // 生产者方法
    public void put(T item) throws InterruptedException {
        synchronized (lock) {
            while (!notFull()) { // 循环检查守卫条件
                lock.wait(); // 条件不满足时挂起
            }
            // 执行放入操作...
            buffer[putPos] = item;
            putPos = (putPos + 1) % buffer.length;
            ++count;
            lock.notifyAll(); // 唤醒可能等待的消费者
        }
    }
    // 消费者方法
    public T take() throws InterruptedException {
        synchronized (lock) {
            while (!notEmpty()) { // 循环检查守卫条件
                lock.wait(); // 条件不满足时挂起
            }
            // 执行取出操作...
            T item = buffer[takePos];
            buffer[takePos] = null; // 可选：清理内存
            takePos = (takePos + 1) % buffer.length;
            --count;
            lock.notifyAll(); // 唤醒可能等待的生产者或其他消费者
            return item;
        }
    }

31.4 虚假唤醒的处理

在Java的wait()方法中，线程可能会在没有其他线程调用notify()或notifyAll()的情况下被唤醒，这被称为“虚假唤醒”。因此，在Guarded Suspension模式中，我们总是将等待操作放在while循环中，而不是if语句中，以确保只有在守卫条件真正满足时才继续执行。

31.5 优点与局限性

优点：

• 代码清晰：通过封装等待唤醒逻辑，使代码更加简洁易懂。
• 减少错误：自动处理虚假唤醒，减少因直接使用wait()和notify()导致的错误。
• 灵活性：可以根据需要轻松调整守卫条件和同步逻辑。

局限性：

• 性能开销：每次唤醒后都需要重新检查条件，可能增加CPU使用率。
• 死锁风险：尽管Guarded Suspension模式本身不直接导致死锁，但错误的同步逻辑或锁使用方式仍可能引发死锁。

31.6 高级话题：使用java.util.concurrent包

Java并发包java.util.concurrent提供了许多高级并发工具，如BlockingQueue、Semaphore等，这些工具内部已经实现了高效的等待唤醒机制，并且更加安全易用。对于许多并发场景，直接使用这些工具可能是更好的选择。

例如，使用ArrayBlockingQueue可以非常方便地实现上述的生产者-消费者问题，而无需手动编写复杂的等待唤醒逻辑。

ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);
// 生产者
new Thread(() -> {
    try {
        queue.put(1); // 自动处理等待唤醒逻辑
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();
// 消费者
new Thread(() -> {
    try {
        System.out.println(queue.take()); // 自动处理等待唤醒逻辑
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

31.7 结论

Guarded Suspension模式提供了一种规范化实现等待唤醒机制的方法，它通过封装Java的wait()和notify()方法，降低了直接使用这些方法的复杂性和出错率。然而，随着Java并发工具的不断丰富，开发者应当根据具体场景选择合适的并发工具，以提高开发效率和代码质量。无论是直接使用Guarded Suspension模式还是利用java.util.concurrent包中的高级工具，理解等待唤醒机制的基本原理都是至关重要的。