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

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

Patricia Arquette
Patricia ArquetteOriginal
2024-12-29 06:12:16876browse

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;
    }
}

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();
        }
    }
}

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!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn