When Together With How To Role The Wait() Together With Notify(), Nofityall() Methods Inwards Java? - Representative Tutorial

When should you lot purpose the wait() too notify method inwards Java is i of the many pop questions almost the hold back too notify methods from Java multithreading interview questions. One of the reasons for its popularity is that yet a lot of Java programmer create out to explicate too write code using wait-notify methods.  Many Java developer alone knows roughly facts almost the hold back too notify methods similar that wait() too notify() are defined inwards the java.lang.Object shape or you lot cannot telephone phone wait() without synchronization, way without a synchronized block or synchronized method but doesn't actually know when too how to purpose them.

In this article, nosotros volition endeavour to twain that gap past times going through a uncomplicated instance of classical Producer-Consumer Problem too exhibit you lot how you lot tin flaming purpose them spell writing concurrent Java applications for the existent world.

First too maiden off you lot should know that wait(), notify(), too notifyAll() are tools for inter-thread communication inwards Java. By using this method, you lot tin flaming state a thread to halt working too after kickoff processing.

They are the essential edifice block of Java multi-threading applications. In the existent world, you lot tin flaming purpose the wait() too notify() method to implement a producer-consumer designing where most of the multi-threaded application falls. If you lot don't know much almost them, I propose you lot bring together a cardinal course of written report on Java threads like Threading Essentials Mini-Course past times Java Champion, Heinz Kabutz.

How to purpose the wait() too notify() methods inwards Java

You tin flaming purpose wait() too notify() method to communicate betwixt multiple threads, for example, you lot tin flaming state i thread to halt working from roughly other thread based upon roughly condition, after you lot tin flaming notify it to kickoff processing again.

One of the pop instance of wait() too notify() method is to solve the producer-consumer problem, where you lot tin flaming convey either unmarried producer too unmarried consumer or multiple producers too unmarried consumer or merely i producer too multiple consumers.

In this example, you lot volition acquire how to implement multiple producers too unmarried consumer solutions using wait() too notify() inwards Java. If you lot are non familiar amongst notify too notifyAll method, you lot tin flaming farther see The Complete Java Masterclass to acquire more.

Wait-Notify Example To Solve Producer-Consumer Problem 

package tool;   import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.TimeUnit;   /**  * Influenza A virus subtype H5N1 uncomplicated Java Program to demonstrate how to purpose hold back  * too notify() method ofr inter-thread communciation  * inwards Java.   */   public class Hello {     public static void main(String[] args) {     Queue<String> q = new LinkedList<>();     boolean exit = false;     Producer p = new Producer(q, exit);     p.start();     Consumer c = new Consumer(q, exit);     c.start();     }   }   class Producer extends Thread {   private volatile Queue<String> sharedQueue;   private volatile boolean bExit;     public Producer(Queue<String> myQueue, boolean bExit) {     this.sharedQueue = myQueue;     this.bExit = bExit;   }     public void run() {     while (!bExit) {       synchronized (sharedQueue) {         while (sharedQueue.isEmpty()) {           String especial = String.valueOf(System.nanoTime());           sharedQueue.add(item);           System.out.println("Producer added : " + item);           try {             System.out.println("Producer sleeping past times calling wait: " + item);             sharedQueue.wait();             System.out.println("Producer wake up: ");           } catch (InterruptedException e) {             e.printStackTrace();           }         }       }     }   } }   class Consumer extends Thread {   private volatile Queue<String> sharedQueue;   private volatile boolean bExit;     public Consumer(Queue<String> myQueue, boolean bExit) {     this.sharedQueue = myQueue;     this.bExit = bExit;   }     public void run() {       while (!bExit) {         synchronized (sharedQueue) {         while (!sharedQueue.isEmpty()) {           String especial = sharedQueue.poll();           System.out.println("Consumer removed : " + item);           System.out.println("Consumer notifying Producer: " + item);           sharedQueue.notify();         }       }     }   } }   Output: Producer added : 12275948008616 Producer sleeping past times calling wait: 12275948008616 Consumer removed : 12275948008616 Consumer notifying Producer: 12275948008616 Producer wake up:  Producer added : 12275948047960 Producer sleeping past times calling wait: 12275948047960 Consumer removed : 12275948047960 Consumer notifying Producer: 12275948047960 Producer wake up:  Producer added : 12275948082600 Producer sleeping past times calling wait: 12275948082600 Consumer removed : 12275948082600 Consumer notifying Producer: 12275948082600

What's Happening Here?

Producer thread is producing items, adding them into a queue too hence going into wait() country until consumer thread consumes it. When Consumer thread removes the items from the queue, it also notifies the Producer thread to kickoff producing again. 

That's why you lot encounter an ordered output similar Producer added, Producer Sleeping, Consumer Removed, Consumer Notified, too Producer Wakeup. In short, both Producer too Consumer Thread are talking amongst each other using hold back too notify method. 

If you lot take that hold back telephone phone hence the Producer thread volition proceed checking for the queue to kicking the bucket waiting too proceed wasting the CPU cycle. 

Similarly, if you lot take the notify telephone phone hence waiting Producer thread may never wake up.  Btw, if you lot convey problem agreement Producer-Consumer Problem hence I also propose taking a await at  the 

here to acquire why

2) Always cheque the waiting status inwards a loop instead of if block inwards Java, encounter here to acquire why.

3) Remember, you lot tin flaming wake upwards a waiting thread past times using interrupt() method but alone if your waiting thread handles the interrupted exception.

4) Prefer notifyAll() over notify() if you lot are inwards doubt, encounter here to acquire more.

5) Don't forget to telephone phone the wait() too notify() method on the same shared object.


That's all almost when to purpose the hold back too notify method inwards Java. It's a perfect too most native tool for inter-thread communication inwards Java. Influenza A virus subtype H5N1 proficient agreement of wait, notify, too the notifyAll method goes a long way inwards writing a robust too rubber concurrent Java program. If you lot convey whatever problem agreement this problem, delight drib a greenback too I'll endeavour to explain.

Further Learning
The Complete Java Masterclass
50+ Java Multithreading Interview Questions inwards Java
How to avoid deadlock inwards Java programs
Top five Courses to Learn Multithreading and Concurrency inwards Java
Multithreading too Parallel Computing inwards Java


Thanks for reading this article hence far. If you lot similar this article hence delight portion amongst your friends too colleagues. If you lot convey whatever questions or feedback, delight drib a note. 

Share this post