Java Thread wait, notify and notifyAll Example

Filed Under: Java

The Object class in java contains three final methods that allows threads to communicate about the lock status of a resource. These methods are wait(), notify() and notifyAll(). So today we will look into wait, notify and notifyAll in java program.

wait, notify and notifyAll in Java

wait and notify in java, wait notify and notifyAll in java, wait notify example, java thread wait

The current thread which invokes these methods on any object should have the object monitor else it throws java.lang.IllegalMonitorStateException exception.

wait

Object wait methods has three variance, one which waits indefinitely for any other thread to call notify or notifyAll method on the object to wake up the current thread. Other two variances puts the current thread in wait for specific amount of time before they wake up.

notify

notify method wakes up only one thread waiting on the object and that thread starts execution. So if there are multiple threads waiting for an object, this method will wake up only one of them. The choice of the thread to wake depends on the OS implementation of thread management.

notifyAll

notifyAll method wakes up all the threads waiting on the object, although which one will process first depends on the OS implementation.

These methods can be used to implement producer consumer problem where consumer threads are waiting for the objects in Queue and producer threads put object in queue and notify the waiting threads.

Let’s see an example where multiple threads work on the same object and we use wait, notify and notifyAll methods.

Message

A java bean class on which threads will work and call wait and notify methods.


package com.journaldev.concurrency;

public class Message {
    private String msg;
    
    public Message(String str){
        this.msg=str;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String str) {
        this.msg=str;
    }

}

Waiter

A class that will wait for other threads to invoke notify methods to complete it’s processing. Notice that Waiter thread is owning monitor on Message object using synchronized block.


package com.journaldev.concurrency;

public class Waiter implements Runnable{
    
    private Message msg;
    
    public Waiter(Message m){
        this.msg=m;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        synchronized (msg) {
            try{
                System.out.println(name+" waiting to get notified at time:"+System.currentTimeMillis());
                msg.wait();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
            System.out.println(name+" waiter thread got notified at time:"+System.currentTimeMillis());
            //process the message now
            System.out.println(name+" processed: "+msg.getMsg());
        }
    }

}

Notifier

A class that will process on Message object and then invoke notify method to wake up threads waiting for Message object. Notice that synchronized block is used to own the monitor of Message object.


package com.journaldev.concurrency;

public class Notifier implements Runnable {

    private Message msg;
    
    public Notifier(Message msg) {
        this.msg = msg;
    }

    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name+" started");
        try {
            Thread.sleep(1000);
            synchronized (msg) {
                msg.setMsg(name+" Notifier work done");
                msg.notify();
                // msg.notifyAll();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

}

WaitNotifyTest

Test class that will create multiple threads of Waiter and Notifier and start them.


package com.journaldev.concurrency;

public class WaitNotifyTest {

    public static void main(String[] args) {
        Message msg = new Message("process it");
        Waiter waiter = new Waiter(msg);
        new Thread(waiter,"waiter").start();
        
        Waiter waiter1 = new Waiter(msg);
        new Thread(waiter1, "waiter1").start();
        
        Notifier notifier = new Notifier(msg);
        new Thread(notifier, "notifier").start();
        System.out.println("All the threads are started");
    }

}

When we will invoke the above program, we will see below output but program will not complete because there are two threads waiting on Message object and notify() method has wake up only one of them, the other thread is still waiting to get notified.


waiter waiting to get notified at time:1356318734009
waiter1 waiting to get notified at time:1356318734010
All the threads are started
notifier started
waiter waiter thread got notified at time:1356318735011
waiter processed: notifier Notifier work done

If we comment the notify() call and uncomment the notifyAll() call in Notifier class, below will be the output produced.


waiter waiting to get notified at time:1356318917118
waiter1 waiting to get notified at time:1356318917118
All the threads are started
notifier started
waiter1 waiter thread got notified at time:1356318918120
waiter1 processed: notifier Notifier work done
waiter waiter thread got notified at time:1356318918120
waiter processed: notifier Notifier work done

Since notifyAll() method wake up both the Waiter threads and program completes and terminates after execution. That’s all for wait, notify and notifyAll in java.

Comments

  1. pratap singh says:

    Hi Sir,
    My question is very simple Why “wait” method is there in object class bcz of we are mostly using in wait method in thread class and is there any reason apart from thread u can also use “wait”method in other place then please write the few code without using the thread concept

  2. Yoad says:

    Hey, still on the Notify exaple (notiftyAll commented out). How can I check something like “if one of them is stuck, release it”?
    I tried the following:
    if (t1.isAlive() ^ t2.isAlive) // one of them is alive and the other finished
    msg.notify();
    But that doesn’t really do anything.
    (What I’m asking is, how to terminate the program “safely” because we know for sure some thread is stuck. Also, is this a case of starvation?)

  3. Mahdavi says:

    Hi Pankaj,

    Can you also please explain the usage of Condition methods in place of wait(), notify() and notifyAll()?

  4. Vignesh M says:

    The wait() method has to be invoked in a loop, right?

  5. Java Dev says:

    This will not work all the time. If the notifier thread get the lock first, its notify call will be ignored and other threads will always be waiting.

    1. Test says:

      True,,, 😀 😀

      1. Swapnil Y Patil says:

        to void this do following.

        Thread.sleep(1000);
        Notifier notifier = new Notifier(msg);

        1. jack says:

          In the Notifier class, below statement is getting executed.
          Thread.sleep(1000);
          So, the program will just work fine expect the fact that you can use notifyAll() in place of notify(). Which he has done only to explain the difference.

  6. Simmant says:

    nice tutorial

  7. Bhavesh Vani says:

    Which thread will be invoked after notify and notifyAll is this details stored anywhere if yes then where?

  8. Aditya Rewari says:

    Nice.

    Never marked so well the difference between notify() & notifyAll()

  9. Anirudh Kanth says:

    There is one edge case scenario though in above example.
    If notifier calls notify(), it will wake up single waiter thread, either waiter or waiter2.
    We must call notifyAll() in such cases or the other thread will keep waiting.

  10. Niraj says:

    ‘msg’ field in Waiter and Notifier are different instances. How come notify call on ‘msg’ of Notifier will notify ‘msg’ of Waiter?

    1. Anirudh Kanth says:

      ‘pass by reference’

  11. mayank sharma says:

    what if notify thread gets the CPU first ?

  12. Sriharsha says:

    how come another waiter thread enter the synchronized block,if already a waiter thread is waiting in that block? please explain
    I have tested with other examples and all other threads seem to wait to enter the synchronized block when one of the threads is in synchronized block and the new thread enters the synchronized block right after the old one leaves the block

    1. Likhit Gatagat says:

      Hello Sriharsha,

      When we call wait method on the object, current thread goes in waiting state, and during wait period it gives away lock so that other thread in Runnable pool can get a chance to execute who were waiting to acquire lock on object, Synchronized block assures that there will be only one thread a time in the synchronized block, and when thread goes in waiting state by calling wait method it no more holds lock on object.

      I hope this clarifies your doubt.

      1. Sriharsha says:

        Thanks Likhit.It clarified my doubt

  13. Rishabh Kashyap says:

    Hi
    This is good example explaining thread communication.You can make it better if you introduce pause in main method after creating waiter thread because when I tried your example main thread was creating notifier thread before waiter thread.
    Here is new main method .I have put main thread to sleep fo 3 seconds giving time for waiter threads to start.

    public class WaitNotifyTest {

    public static void main(String[] args) {

    Message msg = new Message(“process it”);
    Waiter waiter = new Waiter(msg);
    new Thread(waiter, “waiter”).start();

    Waiter waiter1 = new Waiter(msg);
    new Thread(waiter1, “waiter1”).start();
    // Allow waiter threads to start
    try {
    Thread.sleep(3000);
    } catch (InterruptedException e) {

    e.printStackTrace();
    }

    Notifier notifier = new Notifier(msg);
    new Thread(notifier, “notifier”).start();
    System.out.println(“All the threads are started”);

    }

    }

  14. Rahul says:

    package two;

    public class balance {
    int currentBalance;
    public balance(int currentBalance){
    this.currentBalance=currentBalance;
    }

    public void add(int currentBalance){
    this.currentBalance=currentBalance;
    currentBalance++;
    }
    public void deduct(int currentBalance){
    this.currentBalance=currentBalance;
    currentBalance–;
    }
    public int showBalance(){
    return currentBalance;
    }

    }
    —————————————————————————————————————————————-

    package two;

    public class waiter implements Runnable{
    private balance bal;
    int currentBalance= bal.showBalance();
    public waiter(balance bal){
    this.bal= bal;
    }
    @Override
    public void run() {
    synchronized (bal){

    String name= Thread.currentThread().getName();
    System.out.println(name);
    System.out.println(bal.showBalance());
    System.out.println(“in waiter thread waiting for notification”);
    try {
    bal.wait();
    } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    System.out.println(“waiting over now processing”);
    for (int i=0;i<10;i++){
    bal.add(currentBalance);
    }

    }}

    }
    —————————————————————————————————————————————–
    package two;

    public class notifier implements Runnable {
    private balance bal;
    int currentBalance= bal.showBalance();
    public notifier(balance bal){
    this.bal= bal;
    }
    @Override
    public void run() {
    synchronized (bal){
    String name= Thread.currentThread().getName();
    System.out.println(name);
    System.out.println(bal.showBalance());
    System.out.println("in notifier thread");
    for (int i=0;i<10;i++){
    bal.add(currentBalance);
    }
    bal.notifyAll();
    }

    }

    }
    —————————————————————————————————————————————
    package two;

    public class balcheck {
    public static void main(String args[]) {
    balance bal = new balance(10);
    Thread notifiere= new Thread(new notifier(bal));
    notifiere.start();
    Thread waiterre= new Thread(new waiter(bal));
    waiterre.start();
    }

    }
    —————————————————————————————————————————————–

    Hi Pankaj, Can you please help me to debug it, I am getting the following error::
    Exception in thread "main" java.lang.NullPointerException
    at two.notifier.(notifier.java:5)
    at two.balcheck.main(balcheck.java:6)

    1. Guest says:

      Hi
      int currentBalance= bal.showBalance(); in the init , “bal” is null , when u try to initalize currentBalance , u will get NullPointerException

  15. Vidita says:

    Very lucid explanation. I visit this site every time I find any concept difficult to understand.
    Thanks a lot !!!

  16. Raghava says:

    Simply Superb!!

  17. lz says:

    I am confused that waiter and notifier all use “sychronized” on the same “msg” object.
    It seems that the syschronized code block will block the thread, and there should be only 1 of the 3 threads fetch the msg object at any time.
    But, in fact things don’t go on as my imagination, and 3 threads can reach synchronized code cocurrently…

    please explain this, thansk a lot~

  18. Pruthvi Raj says:

    Straight forward example thanks a lot.

  19. vijayaraja says:

    Excellent example.. waited for long time to see such example.

  20. Abha says:

    Thanks. Its a very nice example….

  21. rajesh says:

    Thankyou for the tutorial.

    I have read that we should always use wait in loop ., to prevent false notification . If I am wrong .Please let me know..

    1. navinm says:

      u r talking about finite wait because wait() is blocking call

      while(true){
      obj.wait(time in ms)
      }

  22. Paul Yang says:

    Hi Sir, Could you share or refer some code of how wait , join , notify used in project . even though i have go through the tutorials and understand what you said, however, i have no idea how to put these into my project.

  23. byboating says:

    Thanks a lot for your great job share java to us.

    In this article, Other two variances puts the current thread in ‘wait’ for specific amount of time before ‘they’ wake up.
    Maybe it should be ‘it’ wake up? Or puts the current thread in ‘wait sets’?

    Looking forward to your response!

  24. Sudarsan says:

    Simple and Clear Explanation.

    Thank You !

  25. chandu says:

    how to make sure that one thread is executed onther(multiple threads).

    1. aly says:

      Use join. Next thread will wait till previous thread finish its work on which join was called.

      1. abinaya says:

        First and main difference between notify() and notifyAll() method is that, if multiple thread is waiting on any lock in Java, notify only inform one of waiting thread while notifyAll informs all threads waiting on that lock.

  26. chandu says:

    Hi pankaj and All,

    i have one requirement in threads.
    Requirement: i have three threads.so how to make sure that one thread is exeucted after another.ie thread1 followed bye thread two =>is followed by threade three. please help me

    1. Mark Gonzalez says:

      Don’t use multiple threads.

      Just do the work that you want done by thread 1 followed by the work you want done by thread2 followed by the work you want done by thread 3.

      Make it synchronous … why add the complexity of Threading, when you don’t need parallel processing?

  27. Nanda says:

    Thanks for this article. Really helpful for freshers and experienced people. In your next article please come up with some real time scenarios which you have faced in development in the next article through which increases in clarity of concept.

  28. Vignesh Kanna M says:

    Excellent examples…. continue more on collections…if you have blogs already please give link here

    Thanks & Regards,
    Vignesh Kanna M
    S/w Eng, Chennai, India.

    1. Pankaj says:

      check the footer links, you will find tutorial on collections.

      1. Guru says:

        Hi Pankaj, Thank u for ur example program. Instead of calling msg.notify(), if i call “notify()”, getting “java.lang.IllegalMonitorStateException”…. . Could u explain this plz

  29. Anind says:

    Thanks a lot… It really cleared my confusion

  30. Rudi says:

    Thanks a lot for making it simple to understand

  31. Jaykishan says:

    Thanks sir…it was realyyyyyy helpful…god bless u for ur effort

  32. Ruhina says:

    i have a doubt here..

    In waiter class,waiter got a lock on msg object using synchronized(msg).Now waiter1 has been started also..How can waiter1 get the lock again on msg object using synchronized(msg) when waiter is already holding lock on msg object

    1. Pankaj says:

      When msg.wait() method is called, Waiter threads are releasing the lock on msg.
      Now when notify() method is called in Notifier thread, only one of the thread gets notified and other threads are in wait state.
      When notifyAll() method is called, all the waiter threads are getting notified and then one of them gets the lock on msg and process. Once the first waiter thread releases the lock on msg, second thread gets the lock and completes it’s processing.

      1. mahendar reddy says:

        What happens when “notifier” Thread started first according JVM specifications order of execution of threads may not be in the order of calling. some times, I am facing same issue.
        could you help me please.

        1. Pankaj says:

          If notified thread is execute first, obviously none of the threads will get notified and program will not terminate.

          1. mahendar reddy says:

            Thanks of explanation. is there any way we can make program to tell execute waiter thread first ,then waiter1 and notifier.
            Could you provide example on volatile variable.

  33. Rajendra Verma says:

    thank you very much.It is really helpful

  34. sandeep says:

    The program is good but in that on miss take we have to set the wait time in waiter class other wise it will go for idel sleep time. so in that we have to set the time.

  35. Nitya says:

    Why wait(),notify(),notifyAll() are in object class?please reply..Thanks

    1. Divya says:

      In inter thread communication, all the thread share locks among them and every object has one lock. All these 3 final methods are related to lock and object has a lock.

Leave a Reply

Your email address will not be published. Required fields are marked *

close
Generic selectors
Exact matches only
Search in title
Search in content
Search in posts
Search in pages