How To Role Wait, Notify Too Notifyall Inward Coffee - Producer Consumer Example

You tin purpose wait, notify together with notifyAll methods to communicate betwixt threads inwards Java. For example, if y'all conduct hold 2 threads running inwards your plan e.g.Producer together with Consumer therefore producer thread tin communicate to the consumer that it tin start consuming instantly because at that topographic point are items to eat inwards the queue. Similarly, a consumer thread tin nation the producer that it tin every bit good start putting items instantly because at that topographic point is about infinite inwards the queue, which is created every bit a resultant of consumption. H5N1 thread tin purpose wait() method to time out together with do nil depending upon about condition. For example, inwards the producer-consumer problem, producer thread should await if the queue is total together with consumer thread should await if the queue is empty.

If about thread is waiting for about status to acquire true, y'all tin purpose notify together with notifyAll methods to inform them that status is instantly changed together with they tin wake up.

Both notify() together with notifyAll() method sends a notification but notify sends the notification to solely 1 of the waiting thread, no guarantee which thread volition have notification together with notifyAll() sends the notification to all threads.

So if solely 1 thread is waiting for an object lock, every bit good known every bit a monitor therefore both notify together with notifyAll volition post the notification to it. If multiple threads are waiting on a monitor therefore notify volition solely inform 1 of the lucky thread together with residuum volition non have whatever notification, but notifyAll volition inform all threads.

In this Java multi-threading tutorial y'all volition acquire how to purpose wait, notify together with notifyAll() method inwards Java to implement inter-thread communication past times solving the producer-consumer problem.

BTW, if y'all are serious virtually mastering concurrency together with multi-threading, I strongly advise y'all to read Java Concurrency inwards Practice past times Brian Goetz, without reading that mass your journeying to Java multi-threading is non complete. It's likely 1 of the most recommended books to Java developers.

How to purpose await together with notify inwards code

Even though await together with notify are quite a primal concept together with they are defined inwards the object class, surprisingly, it's non slowly to write code using await together with notify. You tin bear witness this during an interview past times scream for the candidate to write code to solve producer consumer work using await together with notify past times hand.

I am certain many volition last stuck together with brand mistakes e.g. synchronizing at the incorrect place, non calling await on a correct object or non next measure idiom. To last honest its confusing for non-regular coders.

First confusion arise from the fact, how to telephone band wait() method? Since wait method is non defined inwards Thread class, y'all cannot merely telephone band Thread.wait(), that won't operate but since many Java developers are used to calling Thread.sleep() they travail the same affair amongst wait() method together with stuck.

You demand to telephone band wait() method on the object which is shared betwixt 2 threads, inwards producer-consumer work its the queue which is shared betwixt producer together with consumer threads.

The minute confusion comes from the fact that await needs to last a telephone band from synchronized block or method? So if y'all purpose synchronized block, which object should last position to popular off within the block? This should last the same object, whose lock y'all desire to acquire i.e. the shared object betwixt multiple threads. In our instance it's queue.

Always telephone band await together with notify from Loop Instead of If Block

Once y'all know that y'all demand to telephone band await from synchronized context together with on the shared object, side past times side affair is to avoid error made past times several Java developer past times calling wait() method within if block instead of while loop.

Since y'all telephone band await within a conditional block e.g. producer thread should telephone band wait() if queue is full, get-go instinct goes towards using if block, but calling wait() within if block tin Pb to subtle bugs because it's possible for thread to wake upwards spuriously fifty-fifty when waiting status is non changed.

If y'all don't cheque the status 1 time to a greater extent than afterward waking upwards past times using a loop, y'all volition conduct hold the incorrect activity which may drive work e.g. trying to insert special on a total queue or trying to eat from an empty queue. That's why y'all should ever telephone band await together with notify method from a loop together with non from if block.

I every bit good advise reading Effective Java special on the same topic, likely the best reference inwards how to properly telephone band await together with notify method.

Based upon to a higher house noesis hither is  the measure code template or idiom to telephone band await together with notify method inwards Java :

// The measure idiom for calling the wait method inwards Java synchronized (sharedObject) {    while (condition) {       sharedObject.wait(); // (Releases lock, together with reacquires on wakeup)    }    ... // do activity based upon status e.g. conduct hold or position into queue }

As I suggested, y'all should ever invoke await method from a loop. The loop is used to bear witness the status earlier together with afterward waiting. If the status nevertheless holds together with the notify (or notifyAll) method has already been invoked earlier a thread calls wait() method, therefore at that topographic point is no guarantee that the thread volition ever awake from the wait, potentially causing a deadlock.

Java wait(), notify() together with notifyAll() Example

Here is our sample plan to demonstrate how to purpose await together with notify method inwards Java. In this program, nosotros conduct hold used the measure idiom discussed to a higher house to telephone band wait(), notify() together with notifyAll() method inwards Java.

In this program, nosotros conduct hold 2 threads named PRODUCER together with CONSUMER together with implemented using Producer together with Consumer flat which extends Thread class. The logic of what producer together with the consumer should do is written inwards their respective run() method.

Main thread starts both producer together with consumer threads together with every bit good do an object of LinkedList flat to percentage every bit Queue betwixt them. If y'all don't know LinkedList every bit good implements Queue interface inwards Java.

Producer runs inwards an infinite loop together with keeps inserting random integer value into Queue until the queue is full. We cheque this status at while(queue.size == maxSize), scream back earlier doing this cheque nosotros synchronize on queue object therefore that no other thread modify the queue when nosotros are doing this check.

If Queue is total therefore our PRODUCER thread waits until CONSUMER thread eat 1 special together with brand infinite inwards your queue together with telephone band notify() method to inform PRODUCER thread. Both wait() together with notify() method are called on shared object which is queue inwards our case.

import java.util.LinkedList; import java.util.Queue; import java.util.Random;  /**  * Simple Java plan to demonstrate How to purpose wait, notify together with notifyAll()  * method inwards Java past times solving producer consumer problem.  *   * @author Javin Paul  */ public class ProducerConsumerInJava {      public static void main(String args[]) {         System.out.println("How to purpose await together with notify method inwards 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 volition maintain producing values for Consumer  * to consumer. It volition purpose wait() method when Queue is total  * together with purpose notify() method to post 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 conduct hold 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 volition consumer values shape shared queue.  * It volition every bit good purpose wait() method to await if queue is  * empty. It volition every bit good purpose notify method to post   * notification to producer thread afterward 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 position something inwards queue");                     try {                         queue.wait();                     } catch (Exception ex) {                         ex.printStackTrace();                     }                  }                 System.out.println("Consuming value : " + queue.remove());                 queue.notifyAll();             }          }     } }  Output How to purpose await together with notify method inwards Java Solving Producer Consumper Problem Queue is empty,Consumer thread is waiting for producer thread to position something inwards 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 conduct hold 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 position something inwards queue Producing value : 1182138498

In lodge to sympathise this plan better, I advise y'all debug it instead of running. Once y'all start your plan inwards debug means it volition halt at either PRODUCER or CONSUMER thread, depending upon which 1 thread scheduler chose to give CPU.

Since both threads conduct hold await status they volition popular off there, instantly y'all exactly run it together with come across what it does, it volition most probable impress the output shown above. You tin fifty-fifty use Step Into together with Step Over buttons inwards Eclipse to run the plan measuring past times measuring to sympathise it better.

Things to Remember virtually Using wait(), notify() together with notifyAll() method 

1. You tin purpose wait() together with notify() method to implement inter-thread communication inwards Java. Not exactly 1 or 2 threads but multiple threads tin communicate to each other past times using these methods.
2. Always telephone band wait(), notify() together with notifyAll() methods from synchronized method or synchronized block otherwise JVM volition throw IllegalMonitorStateException.
3. Always telephone band await together with notify method from a loop together with never from if() block, because loop bear witness waiting status earlier together with afterward sleeping together with handles notification fifty-fifty if waiting for the status is non changed.
4. Always telephone band await inwards shared object e.g. shared queue inwards this example.
5. Prefer notifyAll() over notify() method due to reasons given inwards this article. 

That's all virtually how to purpose wait, notify together with notifyAll() method inwards Java. You should purpose await together with notify for inter-thread communication inwards Java solely if y'all know what y'all are doing otherwise at that topographic point are many high-level concurrency utilities available for the unlike task.

For example, if y'all desire to implement producer-consumer pattern therefore y'all tin purpose BlockingQueue which volition cope both thread-safety together with menses command for y'all if y'all desire your thread should await for other threads earlier proceeding y'all tin purpose CycliBarrier or CountDownLatch or if y'all desire to protect resources y'all tin purpose Semaphore.

Further Learning
Multithreading together with Parallel Computing inwards Java
Java Concurrency inwards Practice - The Book
Applying Concurrency together with Multi-threading to Common Java Patterns
Java Concurrency inwards Practice Course past times Heinz Kabutz