Простое использование сценария ожидает () и уведомляет () в Java

Методы 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() находятся в синхронизированной области кода (причем вызовы 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, поскольку он охватывает все, что вы хотите знать о проблемах и решениях, связанных с параллелизмом.