Mastering Multithreading in Java: Part 8 – wait-notify and Producer-Consumer

Recap of ReadWriteLock

In our last article, we explored the concept of ReadWriteLock (RWLock), which helps manage multiple readers and a single writer when accessing shared resources. By allowing multiple threads to read simultaneously while ensuring only one thread can write at a time, we improved performance in read-heavy scenarios.

Today, we’ll focus on two more critical multithreading concepts in Java: the wait-notify mechanism and how it relates to the Producer-Consumer problem, a classic example in concurrent programming. Let’s get started!

Understanding wait() and notify()

In Java, wait(), notify(), and notifyAll() are fundamental methods that allow threads to communicate with each other. These methods are used in situations where one thread needs to wait for a condition to be fulfilled by another thread, and they all belong to the Object class.

Here’s a breakdown of what each method does:

• wait(): This causes the current thread to release the lock it holds and wait until another thread calls notify() or notifyAll() on the same object. The thread goes into a waiting state and only resumes when it’s notified.
• notify(): Wakes up one of the threads that are waiting on the object’s lock. However, it does not immediately give the lock to the notified thread; the lock is only available when the current thread releases it.
• notifyAll(): Wakes up all threads waiting on the object’s lock, but only one of them will be able to acquire the lock once the current thread releases it.

These methods are particularly useful in situations where threads need to coordinate their activities. One of the most common examples is the Producer-Consumer problem.

The Producer-Consumer Problem

In the Producer-Consumer problem, one or more producer threads generate data and place it into a shared resource (like a buffer), while one or more consumer threads retrieve and process the data. The producer and consumer must be synchronized so that the producer doesn’t overflow the buffer, and the consumer doesn’t try to consume from an empty buffer.

Let’s walk through an example of how the wait() and notify() methods can be used to solve this problem.

Implementing Producer-Consumer with wait() and notify()

Here’s a basic implementation of the Producer-Consumer problem using wait() and notify():

class SharedBuffer {
    private Queue<Integer> buffer = new LinkedList<>();
    private final int MAX_SIZE = 5;

    public synchronized void produce(int value) throws InterruptedException {
        while (buffer.size() == MAX_SIZE) {
            wait();  // Buffer is full, wait for consumer
        }
    
        buffer.add(value);
        System.out.println("Produced: " + value);
        notify();  // Notify consumer that data is available
    }

    public synchronized void consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait();  // Buffer is empty, wait for producer
        }

        int value = buffer.poll();
        System.out.println("Consumed: " + value);
        notify();  // Notify producer that there's space in the buffer
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        SharedBuffer buffer = new SharedBuffer();
        Thread producer = new Thread(() -> {
    
            try {
                for (int i = 0; i < 10; i++) {
                    buffer.produce(i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    buffer.consume();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
        producer.start();
        consumer.start();
    }
}        

In this example:

• The producer adds integers to the buffer.
• The consumer removes integers from the buffer.
• The wait() method ensures the producer waits if the buffer is full and the consumer waits if the buffer is empty.
• The notify() method wakes up the other thread when the buffer has space (for the producer) or data (for the consumer).

Best Practices for wait-notify

Using wait() and notify() is powerful, but there are some best practices you should keep in mind to avoid common pitfalls:

• Always call wait() in a loop: This is because spurious wakeups can occur, meaning a thread may wake up even if it wasn’t notified. Therefore, the condition should always be checked before proceeding.

while (buffer.isEmpty()) {
    wait();
}        

• Keep critical sections as small as possible: Make sure that the synchronized blocks around wait() and notify() are minimal to avoid unnecessary blocking of other threads.
• Use notifyAll() with care: If multiple threads are waiting, using notifyAll() can wake all of them up, even if only one can proceed. In some cases, this can lead to inefficiencies, but it is safer when you don’t know which thread should be notified.

Benefits of wait-notify in Producer-Consumer

The wait() and notify() mechanism ensures that:

• Producers don’t overwhelm consumers: If the buffer is full, the producer will wait until the consumer consumes an item.
• Consumers don’t consume from an empty buffer: If the buffer is empty, the consumer waits until the producer adds an item.

Challenges with wait-notify

While wait() and notify() are simple and effective for basic use cases, they can become tricky in complex applications. The main issues are:

• Potential deadlocks: Improperly used wait() and notify() can result in deadlocks, where both the producer and consumer are stuck waiting.
• Code complexity: Synchronized methods and wait-notify logic can make code harder to maintain.

To address these challenges, higher-level constructs like BlockingQueue or Condition (from java.util.concurrent.locks) may be preferable for more sophisticated applications.

Conclusion: Mastering wait-notify and Producer-Consumer

In this article, we’ve explored how wait() and notify() can be used to implement the Producer-Consumer problem in Java. This is a fundamental multithreading concept that will help you handle communication between threads efficiently.

By mastering these techniques, you can ensure that your multithreaded applications run smoothly without unnecessary waits or race conditions. In the next article, we’ll look at more advanced synchronization techniques, including BlockingQueue and how it simplifies producer-consumer scenarios.

Previously Covered Topics in This Series:

• Mastering Multithreading in Java: Part 1 - An Easy Introduction
• Mastering Multithreading in Java: Part 2 - Creation, Join, and Daemon
• Mastering Multithreading in Java: Part 3 – Sleep, Interrupt, and Understanding Them
• Mastering Multithreading in Java: Part 4 – Synchronization and the Synchronized Keyword
• Mastering Multithreading in Java: Part 5 – ReentrantLock and Volatile
• Mastering Multithreading in Java: Part 6 – Atomic Variables and Deadlock
• Mastering Multithreading in Java: Part 7 – ReadWriteLock (RWLock)