java - java中使用wait()和notify()的简单场景

Question

我能否获得一个完整的简单场景，即建议如何使用它的教程，特别是与队列一起使用？

Answer 1

wait() 和 notify() 方法旨在提供一种机制，允许线程阻塞直到满足特定条件。为此，我假设您想要编写一个阻塞队列实现，其中您有一些固定大小的元素后备存储。

您要做的第一件事是确定您希望方法等待的条件。在这种情况下，您将希望 put() 方法阻塞，直到存储中有空闲空间，并且您希望 take() 方法阻塞，直到那里是一些要返回的元素。

public class BlockingQueue<T> {

    private Queue<T> queue = new LinkedList<T>();
    private int capacity;

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void put(T element) throws InterruptedException {
        while(queue.size() == capacity) {
            wait();
        }

        queue.add(element);
        notify(); // notifyAll() for multiple producer/consumer threads
    }

    public synchronized T take() throws InterruptedException {
        while(queue.isEmpty()) {
            wait();
        }

        T item = queue.remove();
        notify(); // notifyAll() for multiple producer/consumer threads
        return item;
    }
}

关于必须使用等待和通知机制的方式，有几点需要注意。

首先，您需要确保对 wait() 或 notify() 的任何调用都在同步的代码区域内(使用 wait() 和 notify() 调用在同一个对象上同步)。造成这种情况的原因(除了标准线程安全问题)是由于被称为丢失信号的东西。

这方面的一个例子是，一个线程可能会在队列恰好满时调用 put()，然后它会检查条件，发现队列已满，但是在它可以阻塞之前安排了另一个线程。然后第二个线程 take() 是队列中的一个元素，并通知等待线程队列不再满。但是，因为第一个线程已经检查了条件，所以它会在重新调度后简单地调用 wait()，即使它可以取得进展。

通过在共享对象上进行同步，您可以确保不会发生此问题，因为在第一个线程实际阻塞之前，第二个线程的 take() 调用将无法进行。

其次，由于被称为虚假唤醒的问题，您需要将要检查的条件放在 while 循环中，而不是 if 语句中。这就是有时可以重新激活等待线程而不调用 notify() 的地方。把这个检查放在一个while循环中会确保如果发生虚假唤醒，会重新检查条件，线程会再次调用wait()。

---

正如其他一些答案所提到的，Java 1.5 引入了一个新的并发库(在 java.util.concurrent 包中)，旨在提供对等待/通知的更高级别的抽象机制。使用这些新功能，您可以像这样重写原始示例:

public class BlockingQueue<T> {

    private Queue<T> queue = new LinkedList<T>();
    private int capacity;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public void put(T element) throws InterruptedException {
        lock.lock();
        try {
            while(queue.size() == capacity) {
                notFull.await();
            }

            queue.add(element);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while(queue.isEmpty()) {
                notEmpty.await();
            }

            T item = queue.remove();
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
}

---

当然，如果你真的需要一个阻塞队列，那么你应该使用 BlockingQueue 的实现。界面。

另外，对于这样的东西，我强烈推荐 Java Concurrency in Practice ，因为它涵盖了您可能想了解的有关并发相关问题和解决方案的所有信息。