How to use wait, notify and notifyAll in Java - Producer Consumer Example

You can use wait, notify, and notifyAll methods to communicate between threads in Java. For example, if you have two threads running in your programs like Producer and Consumer then the producer thread can communicate to the consumer that it can start consuming now because there are items to consume in the queue. Similarly, a consumer thread can tell the producer that it can also start putting items now because there is some space in the queue, which is created as a result of consumption. A thread can use the wait() method to pause and do nothing depending upon some condition. For example, in the producer-consumer problem, the producer thread should wait if the queue is full and the consumer thread should wait if the queue is empty.

If some thread is waiting for some condition to become true, you can use notify and notifyAll methods to inform them that the condition is now changed and they can wake up.

Both notify() and notifyAll() method sends a notification but notifies sends the notification to only one of the waiting thread, no guarantee which thread will receive notification and notifyAll() sends the notification to all threads.

So if only one thread is waiting for an object lock, also known as a monitor then both notify and notifyAll will send the notification to it. If multiple threads are waiting on a monitor then notify will only inform one of the lucky threads and the rest will not receive any notification, but notifyAll will inform all threads.

In this Java multi-threading tutorial, you will learn how to use the wait, notify, and notifyAll() method in Java to implement inter-thread communication by solving the producer-consumer problem.

And, if you are serious about mastering Java multi-threading and concurrency then I also suggest you take a look at these best Java Concurrency courses on  Udemy. It's an advanced course to become an expert in Multithreading, concurrency, and Parallel programming in Java with a strong emphasis on high performance

How to use wait and notify in code?

Even though wait and notify are quite fundamental concepts and they are defined in the object class, surprisingly, it's not easy to write code using wait and notify. You can test this during an interview by asking the candidate to write code to solve the producer-consumer problems using wait and notify by hand.

I am sure many will be stuck and make mistakes e.g. synchronizing at the wrong place, not calling wait on a right object, or not following standard idiom. To be honest it's confusing for non-regular coders.

First confusion arises from the fact, how to call the wait() method? Since the wait method is not defined in the Thread class, you cannot simply call Thread.wait(), that won't work but since many Java developers are used to calling Thread.sleep() they try the same thing with wait() method and stuck.

You need to call the wait() method on the object which is shared between two threads, in the producer-consumer problem it's the queue that is shared between producer and consumer threads.

The second confusion comes from the fact that wait needs to be a call from a synchronized block or method? So if you use a synchronized block, which object should be put to go inside the block? This should be the same object, whose lock you want to acquire i.e. the shared object between multiple threads. In our case, it's a queue.

Always call wait and notify from Loop Instead of If Block

Once you know that you need to call wait from synchronized context and on the shared object, the next thing is to avoid mistakes made by several Java developers by calling the wait() method inside if block instead of the while loop.

Since you call wait inside a conditional block e.g. producer thread should call wait() if queue is full, first instinct goes towards using if block, but calling wait() inside if block can lead to subtle bugs because it's possible for a thread to wake up spuriously even when waiting condition is not changed.

If you don't check the condition again after waking up by using a loop, you will take the wrong action which may cause problems e.g. trying to insert an item on a full queue or trying to consume from an empty queue. That's why you should always call the wait and notify method from a loop and not from if block.

I also suggest reading the Effective Java item on the same topic, probably the best reference in how to properly call the wait and notify method.

Based upon the above knowledge here is  the standard code template or idiom to call the wait and notify method in Java :

// The standard idiom for calling the wait method in Java
synchronized (sharedObject) {
   while (condition) {
      sharedObject.wait(); // (Releases lock, and reacquires on wakeup)
   }
   ... // do action based upon condition e.g. take or put into queue
}

As I suggested, you should always invoke the wait method from a loop. The loop is used to test the condition before and after waiting. If the condition still holds and the notify (or notifyAll) method has already been invoked before a thread calls wait for () method, then there is no guarantee that the thread will ever awake from the wait, potentially causing a deadlock.

BTW, if you are serious about mastering concurrency and multi-threading, I strongly suggest you read Java Concurrency in Practice by Brian Goetz, without reading that book your journey to Java multi-threading is not complete. It's probably one of the most recommended books to Java developers.

Java wait(), notify() and notifyAll() Example - Producer Consumer Pattern Example

Here is our sample program to demonstrate how to use the wait and notify method in Java. In this program, we have used the standard idiom discussed above to call wait(), notify(), and notifyAll() method in Java.

In this program, we have two threads named PRODUCER and CONSUMER and implemented using Producer and Consumer class which extends Thread class. The logic of what the producer and the consumer should do is written in their respective run() method.

The main thread starts both producer and consumer threads and also creates an object of LinkedList class to share as Queue between them. If you don't know LinkedList also implements a Queue interface in Java.

Producer runs in an infinite loop and keeps inserting random integer values into Queue until the queue is full. We check this condition at while(queue.size == maxSize), remember before doing this check we synchronize on queue object so that no other thread modifies the queue when we are doing this check.

If Queue is full then our PRODUCER thread waits until CONSUMER thread consumes one item and makes space in your queue and calls notify() method to inform PRODUCER thread. Both wait() and notify() methods are called on shared object which is a queue in our case.

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

/**
 * Simple Java program to demonstrate How to use wait, notify and notifyAll()
 * method in Java by solving producer consumer problem.
 * 
 * @author Javin Paul
 */
public class ProducerConsumerInJava {

    public static void main(String args[]) {
        System.out.println("How to use wait and notify method in Java");
        System.out.println("Solving Producer Consumper Problem");
        
        Queue<Integer> buffer = new LinkedList<>();
        int maxSize = 10;
        
        Thread producer = new Producer(buffer, maxSize, "PRODUCER");
        Thread consumer = new Consumer(buffer, maxSize, "CONSUMER");
        
        producer.start();
        consumer.start();
        

    }

}

/**
 * Producer Thread will keep producing values for Consumer
 * to consumer. It will use wait() method when Queue is full
 * and use notify() method to send notification to Consumer
 * Thread.
 * 
 * @author WINDOWS 8
 *
 */
class Producer extends Thread {
    private Queue<Integer> queue;
    private int maxSize;
    
    public Producer(Queue<Integer> queue, int maxSize, String name){
        super(name);
        this.queue = queue;
        this.maxSize = maxSize;
    }
    
    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.size() == maxSize) {
                    try {
                        System.out .println("Queue is full, "
                                + "Producer thread waiting for "
                                + "consumer to take something from queue");
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }

                Random random = new Random();
                int i = random.nextInt();
                System.out.println("Producing value : " + i);
                queue.add(i);
                queue.notifyAll();
            }

        }
    }
}

/**
 * Consumer Thread will consumer values form shared queue.
 * It will also use wait() method to wait if queue is
 * empty. It will also use notify method to send 
 * notification to producer thread after consuming values
 * from queue.
 * 
 * @author WINDOWS 8
 *
 */
class Consumer extends Thread {
    private Queue<Integer> queue;
    private int maxSize;
    
    public Consumer(Queue<Integer> queue, int maxSize, String name){
        super(name);
        this.queue = queue;
        this.maxSize = maxSize;
    }
    
    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    System.out.println("Queue is empty,"
                            + "Consumer thread is waiting"
                            + " for producer thread to put something in queue");
                    try {
                        queue.wait();
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }

                }
                System.out.println("Consuming value : " + queue.remove());
                queue.notifyAll();
            }

        }
    }
}

Output
How to use wait and notify method in Java
Solving Producer Consumper Problem
Queue is empty,Consumer thread is waiting for producer thread 
to put something in queue
Producing value : -1692411980
Producing value : 285310787
Producing value : -1045894970
Producing value : 2140997307
Producing value : 1379699468
Producing value : 912077154
Producing value : -1635438928
Producing value : -500696499
Producing value : -1985700664
Producing value : 961945684
Queue is full, Producer thread waiting for consumer
 to take something from queue
Consuming value : -1692411980
Consuming value : 285310787
Consuming value : -1045894970
Consuming value : 2140997307
Consuming value : 1379699468
Consuming value : 912077154
Consuming value : -1635438928
Consuming value : -500696499
Consuming value : -1985700664
Consuming value : 961945684
Queue is empty,Consumer thread is waiting for producer 
thread to put something in queue
Producing value : 1182138498

In order to understand this program better, I suggest you debug it instead of running it. Once you start your program in debug mode it will stop at either PRODUCER or CONSUMER thread, depending upon which one thread scheduler chose to give CPU.

Since both threads have wait conditions they will go there, now you just run it and see what it does, it will most likely print the output shown above. You can even use the Step Into and Step Over buttons in Eclipse to run the program step by step to understand it better.

Things to Remember about Using wait(), notify() and notifyAll() method 

1. You can use the wait() and notify() method to implement inter-thread communication in Java. Not just one or two threads but multiple threads can communicate to each other by using these methods.
2. Always call wait(), notify() and notifyAll() methods from synchronized method or synchronized block otherwise JVM will throw IllegalMonitorStateException.
3. Always call wait and notify method from a loop and never from if() block, because loop test waiting condition before and after sleeping and handles notification even if waiting for the condition is not changed.
4. Always call wait in shared object e.g. shared queue in this example.
5. Prefer notifyAll() over notify() method due to reasons given in this article. 

That's all about how to use the wait, notify, and notifyAll() method in Java. You should use wait and notify for inter-thread communication in Java only if you know what you are doing otherwise there are many high-level concurrency utilities available for the different tasks.

For example, if you want to implement a producer-consumer pattern then you can use BlockingQueue which will manage both thread-safety and flow control for you if you want your thread should wait for other threads before proceeding you can use CyclicBarrier or CountDownLatch or if you want to protect resource you can use Semaphore.

Other Java Multithreading and Concurrency tutorials you may like

• What is happens-before in Java concurrency? (answer)
• How to use Future and FutureTask class in Java? (solution)
• Difference between volatile, atomic, and synchronized in Java (answer)
• How to use Semaphore class in Java? (code sample)
• How to use the Lock interface in multi-threaded programming? (code sample)
• How to use Thread pool Executor in Java? (example)
• How to use a CyclicBarrier class in Java? (example)
• 50 Java Thread Questions for Senior and Experienced Programmers (questions)
• How to use the CountDownLatch utility in Java? (example)
• Difference between CyclicBarrier and CountDownLatch in Java? (answer)
• how to do inter-thread communication using wait and notify? (solution)
• How to use ThreadLocal variables in Java? (example)
• Top 5 Concurrent Collection classes from Java 5 and Java 6 (read here)
• 10 Examples of ConcurrentHahsMap in Java (examples)
• 10 Multi-threading and Concurrency Best Practices for Java Programmers (best practices)

Thanks for reading this article so far. If you like this wait, notify, and notifyAll examples in Java then please share it with your friends and colleagues. If you have any questions or feedback then please drop a note. 

P.S. - If you are a Java beginner and need a free course to learn essential Java thread concepts then I highly suggest you join this free Java Multithreading course for beginners. This is the best free online course to learn Java Multithreading from scratch. 

And, lastly one question for you? What is the best way to solve producer consumer problem in Java? wait and notify method, BlockingQueue or SynchronousQueue? If you know the answer let us know in comments.