How Can `wait()` and `notify()` Be Used to Implement a Blocking Queue in Java?

Using wait() and notify() to Implement a Blocking Queue

Introduction

In multithreaded programming, wait() and notify() are used for thread synchronization. This article explains how to use wait() and notify() to implement a blocking queue, a data structure that allows threads to block until an item is available or space becomes available.

Implementing a Blocking Queue with wait() and notify()

Conditions for Blocking:

• put() method: Blocks until there is free space in the queue.
• take() method: Blocks until there is an element available in the queue.

Java Code:

public class BlockingQueue<t> {

    private Queue<t> queue = new LinkedList();
    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;
    }
}</t></t>

Considerations When Using wait() and notify()

• Synchronized Code: Call wait() and notify() within a synchronized method or block.
• While Loops: Use while loops instead of if statements to check conditions due to spurious wake-ups.

Java 1.5 Concurrency Library

Java 1.5 introduced a concurrency library that provides higher-level abstractions:

Modified Blocking Queue Implementation:

public class BlockingQueue<t> {

    private Queue<t> queue = new LinkedList();
    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();
        }
    }
}</t></t>

The above is the detailed content of How Can `wait()` and `notify()` Be Used to Implement a Blocking Queue in Java?. For more information, please follow other related articles on the PHP Chinese website!