Difference between wait and sleep

Question

What is difference between wait and sleep

User · Answer

wait releases the lock and sleep doesn t  A thread in waiting state is eligible for waking up as soon as notify or notifyAll is called  But in case of sleep the thread keeps the lock and it ll only be eligible once the sleep time is over

User · Answer

Lets assume you are hearing songs   As long as the current song is running  the next song wont play  i e Sleep   called by next song  If you finish the song it will stop and until you select play button notify    it wont play  i e wait   called by current song   In this both cases songs going to Wait states

User · Answer

The method wait 1000  causes the current thread to sleep up to one second    A thread could sleep less than 1 second if it receives the notify   or notifyAll   method call   The call to sleep 1000  causes the current thread to sleep for exactly 1 second    Also sleeping thread doesn t hold lock any resource  But waiting thread does

User · Answer

Actually  all this is clearly described in Java docs  but I realized this only after reading the answers    http   docs oracle com javase 8 docs api index html    wait   - The current thread must own this object s monitor  The thread releases  ownership of this monitor and waits until another thread notifies  threads waiting on this object s monitor to wake up either through a  call to the notify method or the notifyAll method  The thread then  waits until it can re-obtain ownership of the monitor and resumes execution   sleep   - Causes the currently executing thread to sleep  temporarily cease execution  for the specified number of milliseconds  subject to the precision and accuracy of system timers and schedulers  The thread does not lose ownership of any monitors

User · Answer

sleep   method causes the current thread to move from running state to block state for a specified time  If the current thread has the lock of any object then it keeps holding it  which means that other threads cannot execute any synchronized method in that class object   wait   method causes the current thread to go into block state either for a specified time or until notify  but in this case the thread releases the lock of the object  which means that other threads can execute any synchronized methods of the calling object

User · Answer

Here wait   will be in the waiting state till it notify by another Thread but where as sleep   will be having some time  after that it will automatically transfer to the Ready state

User · Answer

One potential big difference between sleep interrupt and wait notify is that   calling interrupt   during sleep   always throws an exception  e g  InterruptedException   whereas calling notify   during wait   does not    Generating an exception when not needed is inefficient   If you have threads communicating with each other at a high rate  then it would be generating a lot of exceptions if you were calling interrupt all the time  which is a total waste of CPU

User · Answer

In simple words  wait is wait Until some other thread invokes you whereas sleep is  dont execute next statement  for some specified period of time   Moreover sleep is static method in Thread class and it operates on thread  whereas wait   is in Object class and called on an object   Another point  when you call wait on some object  the thread involved synchronize the object and then waits

User · Answer

Example about sleep doesn   t release lock and wait does  Here there are two classes     Main   Contains main method and two threads  Singleton   This is singleton class with two static methods getInstance   and getInstance boolean isWait    public class Main    private static Singleton singletonA   null  private static Singleton singletonB   null   public static void main String   args  throws InterruptedException    Thread threadA   new Thread          Override     public void run              singletonA   Singleton getInstance true              Thread threadB   new Thread          Override     public void run             singletonB   Singleton getInstance             while  singletonA    null                System out println  SingletonA still null                       if  singletonA    singletonB                System out println  Both singleton are same              else               System out println  Both singleton are not same                         threadA start    threadB start             and  public class Singleton        private static Singleton  instance       public static Singleton getInstance          if   instance    null            synchronized  Singleton class                if   instance    null                   instance   new Singleton                        return  instance      public static Singleton getInstance boolean isWait         if   instance    null            synchronized  Singleton class                if   instance    null                    if  isWait                        try                              Singleton class wait 500    Using wait                         Thread sleep 500     Using Sleep                         System out println   instance                                      String valueOf  instance                          catch  InterruptedException e                            e printStackTrace                                                              instance   new Singleton                                      return  instance          Now run this example you will get below output     instance  null Both singleton are same   Here Singleton instances created by threadA and threadB are same  It means threadB is waiting outside until threadA release it   s lock   Now change the Singleton java by commenting Thread sleep 500   method and uncommenting Singleton class wait 500     Here because of Singleton class wait 500   method threadA will release all acquire locks and moves into the    Non Runnable    state  threadB will get change to enter in synchronized block   Now run again    SingletonA still null SingletonA still null SingletonA still null  instance  com omt sleepwait Singleton 10c042ab SingletonA still null SingletonA still null SingletonA still null Both singleton are not same   Here Singleton instances created by threadA and threadB are NOT same because of threadB got change to enter in synchronised block and after 500 milliseconds threadA started from it   s last position and created one more Singleton object

User · Answer

Difference between wait   and sleep    The fundamental difference is that wait   is from Object and sleep   is a static method of Thread   The major difference is that wait   releases the lock while sleep   doesn   t release any lock while waiting   wait   is used for inter-thread communication while sleep   is used to introduce a pause on execution  generally   wait   should be called from inside synchronise or else we get an IllegalMonitorStateException   while sleep    can be called anywhere   To start a thread again from wait    you have to call notify   or notifyAll    As for sleep    the thread gets started after a specified time interval    Similarities  Both make the current thread go into the Not Runnable state  Both are native methods

User · Answer

wait   with a timeout value can wakeup upon timeout value elapsed or notify whichever is earlier  or interrupt as well    whereas  a sleep   wakes up on timeout value elapsed or interrupt whichever is earlier  wait   with no timeout value will wait for ever until notified or interrupted

User · Answer

source   http   www jguru com faq view jsp EID 47127     Thread sleep   sends the current thread into the  Not Runnable  state   for some amount of time  The thread keeps the monitors it has aquired   -- i e  if the thread is currently in a synchronized block or method no other thread can enter this block or method  If another thread calls t interrupt   it will wake up the sleeping thread       Note that sleep is a static method  which means that it always affects   the current thread  the one that is executing the sleep method   A   common mistake is to call t sleep   where t is a different thread    even then  it is the current thread that will sleep  not the t thread       t suspend   is deprecated  Using it is possible to halt a thread other   than the current thread  A suspended thread keeps all its monitors and   since this state is not interruptable it is deadlock prone       object wait   sends the current thread into the  Not Runnable  state    like sleep    but with a twist  Wait is called on an object  not a   thread  we call this object the  lock object   Before lock wait   is   called  the current thread must synchronize on the lock object  wait     then releases this lock  and adds the thread to the  wait list    associated with the lock  Later  another thread can synchronize on the   same lock object and call lock notify    This wakes up the original    waiting thread  Basically  wait   notify   is like   sleep   interrupt    only the active thread does not need a direct   pointer to the sleeping thread  but only to the shared lock object

User · Answer

sleep just delays the shell for the given amount of seconds   wait makes the shell wait for the given job  e g    workhard  amp   1  27408 workharder  amp   2  27409 wait  1  2   delays the shell until both of the subprocesses have finished

User · Answer

One key difference not yet mentioned is that while sleeping a Thread does not release the locks it holds  while waiting releases the lock on the object that wait   is called on   synchronized LOCK        Thread sleep 1000      LOCK is held     synchronized LOCK        LOCK wait       LOCK is not held

User · Answer

wait   is given inside a synchronized method  whereas sleep   is given inside a non-synchronized method because wait   method release the lock on the object but sleep   or yield   does release the lock

User · Answer

You are correct - Sleep   causes that thread to  sleep  and the CPU will go off and process other threads  otherwise known as context switching  wheras I believe Wait keeps the CPU processing the current thread   We have both because although it may seem sensible to let other people use the CPU while you re not using it  actualy there is an overhead to context switching - depending on how long the sleep is for  it can be more expensive in CPU cycles to switch threads than it is to simply have your thread doing nothing for a few ms   Also note that sleep forces a context switch     Also - in general it s not possible to control context switching - during the Wait the OS may  and will for longer waits  choose to process other threads

User · Answer

There are a lot of answers here but I couldn t find the semantic distinction mentioned on any   It s not about the thread itself  both methods are required as they support very different use-cases   sleep   sends the Thread to sleep as it was before  it just packs the context and stops executing for a predefined time  So in order to wake it up before the due time  you need to know the Thread reference  This is not a common situation in a multi-threaded environment  It s mostly used for time-synchronization  e g  wake in exactly 3 5 seconds  and or hard-coded fairness  just sleep for a while and let others threads work    wait    on the contrary  is a thread  or message  synchronization mechanism that allows you to notify a Thread of which you have no stored reference  nor care   You can think of it as a publish-subscribe pattern  wait    subscribe and notify      publish   Basically using notify   you are sending a message  that might even not be received at all and normally you don t care    To sum up  you normally use sleep   for time-syncronization and wait   for multi-thread-synchronization   They could be implemented in the same manner in the underlying OS  or not at all  as previous versions of Java had no real multithreading  probably some small VMs doesn t do that either   Don t forget Java runs on a VM  so your code will be transformed in something different according to the VM OS HW it runs on

User · Answer

Wait   and sleep   Differences   Thread sleep        Once its work completed then only its release the lock to everyone  until its never release the lock to anyone     Sleep   take the key  its never release the key to anyone  when its work completed then only its release then only take the key waiting stage threads    Object wait       When  its going to waiting stage  its will be release the key and its waiting for some of the seconds based on the parameter    For Example   you are take the coffee in yours right hand  you can take another anyone of the same hand  when will your put down then only take another object same type here  also  this is sleep    you sleep time you didn t any work  you are doing only sleeping   same here also   wait    when you are put down and take another one mean while you are waiting   that s wait  you are play movie or anything in yours system same as player you can t play more than one at a time right  thats its here  when you close and choose another anyone movie or song mean while is called wait

User · Answer

sleep is a method of Thread  wait is a method of Object  so wait notify is a technique of synchronizing shared data in Java  using monitor   but sleep is a simple method of thread to pause itself

User · Answer

This is a very simple question  because both these methods have a totally different use    The major difference is to wait to release the lock or monitor while sleep doesn t release any lock or monitor while waiting  Wait is used for inter-thread communication while sleep is used to introduce pause on execution    This was just a clear and basic explanation  if you want more than that then continue reading   In case of wait   method thread goes in waiting state and it won t come back automatically until we call the notify   method  or notifyAll   if you have more then one thread in waiting state and you want to wake all of those thread   And you need synchronized or object lock or class lock to access the wait   or notify   or notifyAll   methods  And one more thing  the wait   method is used for inter-thread communication because if a thread goes in waiting state you ll need another thread to wake that thread   But in case of sleep   this is a method which is used to hold the process for few seconds or the time you wanted  Because you don t need to provoke any notify   or notifyAll   method to get that thread back  Or you don t need any other thread to call back that thread  Like if you want something should happen after few seconds like in a game after user s turn you want the user to wait until the computer plays then you can mention the sleep   method   And one more important difference which is asked often in interviews  sleep   belongs to Thread class and wait   belongs to Object class   These are all the differences between sleep   and wait     And there is a similarity between both methods  they both are checked statement so you need try catch or throws to access these methods   I hope this will help you

User · Answer

Wait and sleep are two different things     In sleep   the thread stops working for the specified duration  In wait   the thread stops working until the object being waited-on is notified  generally by other threads

User · Answer

wait is a BASH built-in command   From man bash       wait  n              Wait  for each specified process and return its termination sta-         tus   Each n may be a process ID or a job  specification   if  a         job  spec  is  given   all  processes in that job s pipeline are         waited for   If n is not given  all currently active child  pro-         cesses  are  waited  for   and  the return status is zero   If n         specifies a non-existent process or job  the  return  status  is         127    Otherwise   the  return  status is the exit status of the         last process or job waited for    sleep is not a shell built-in command   It is a utility that delays for a specified amount of time   The sleep command may support waiting in various units of time   GNU coreutils 8 4 man sleep says       SYNOPSIS         sleep NUMBER SUFFIX          DESCRIPTION         Pause for NUMBER seconds   SUFFIX may be    s    for seconds  the default              m    for minutes     h    for hours or    d    for days   Unlike most  implemen-         tations  that require NUMBER be an integer  here NUMBER may be an arbi-         trary floating point number   Given two or more  arguments   pause  for         the amount of time specified by the sum of their values

User · Answer

The methods are used for different things   Thread sleep 5000        Wait until the time has passed   Object wait              Wait until some other thread tells me to wake up    Thread sleep n  can be interrupted  but Object wait   must be notified  It s possible to specify the maximum time to wait  Object wait 5000  so it would be possible to use wait to  er  sleep but then you have to bother with locks   Neither of the methods uses the cpu while sleeping waiting    The methods are implemented using native code  using similar constructs but not in the same way   Look for yourself  Is the source code of native methods available  The file  src share vm prims jvm cpp is the starting point

User · Answer

Here  I have listed few important differences between wait   and sleep   methods   PS  Also click on the links to see library code  internal working  just play around a bit for better understanding     wait     wait   method releases the lock    wait   is the method of Object class  wait   is the non-static method - public final void wait   throws InterruptedException           wait   should be notified by notify   or notifyAll   methods  wait   method needs to be called from a loop in order to deal with false alarm  wait   method must be called from synchronized context  i e   synchronized method or block   otherwise  it will throw IllegalMonitorStateException   sleep     sleep   method doesn t release the lock  sleep   is the method of java lang Thread class  sleep   is the static method - public static void sleep long millis  int nanos  throws InterruptedException           after the specified amount of time  sleep   is completed  sleep   better not to call from loop i e  see code below   sleep   may be called from anywhere  there is no specific requirement     Ref  Difference between Wait and Sleep  Code snippet for calling wait and sleep method  synchronized monitor       while condition    true            monitor wait      releases monitor lock            Thread sleep 100     puts current thread on Sleep

User · Answer

sleep   is a method which is used to hold the process for few seconds or the time you wanted but in case of wait   method thread goes in waiting state and it won   t come back automatically until we call the notify   or notifyAll     The major difference is that wait   releases the lock or monitor while sleep   doesn   t releases any lock or monitor while waiting  Wait is used for inter-thread communication while sleep is used to introduce pause on execution  generally   Thread sleep   sends the current thread into the    Not Runnable    state for some amount of time  The thread keeps the monitors it has acquired     i e  if the thread is currently in a synchronized block or method no other thread can enter this block or method  If another thread calls t interrupt   it will wake up the sleeping thread  Note that sleep is a static method  which means that it always affects the current thread  the one that is executing the sleep method   A common mistake is to call t sleep   where t is a different thread  even then  it is the current thread that will sleep  not the t thread   object wait   sends the current thread into the    Not Runnable    state  like sleep    but with a twist  Wait is called on an object  not a thread  we call this object the    lock object     Before lock wait   is called  the current thread must synchronize on the lock object  wait   then releases this lock  and adds the thread to the    wait list    associated with the lock  Later  another thread can synchronize on the same lock object and call lock notify    This wakes up the original  waiting thread  Basically  wait   notify   is like sleep   interrupt    only the active thread does not need a direct pointer to the sleeping thread  but only to the shared lock object   synchronized LOCK          Thread sleep 1000      LOCK is held    synchronized LOCK          LOCK wait       LOCK is not held     Let categorize all above points    Call on    wait    Call on an object  current thread must synchronize on the lock object  sleep    Call on a Thread  always currently executing thread    Synchronized    wait    when synchronized multiple threads access same Object one by one  sleep    when synchronized multiple threads wait for sleep over of sleeping thread    Hold lock    wait    release the lock for other objects to have chance to execute  sleep    keep lock for at least t times if timeout specified or somebody interrupt    Wake-up condition    wait    until call notify    notifyAll   from object sleep    until at least time expire or call interrupt      Usage    sleep    for time-synchronization and  wait    for multi-thread-synchronization    Ref diff sleep and wait

User · Answer

A wait can be  woken up  by another thread calling notify on the monitor which is being waited on whereas a sleep cannot  Also a wait  and notify  must happen in a block synchronized on the monitor object whereas sleep does not   Object mon        synchronized  mon        mon wait         At this point the currently executing thread waits and releases the monitor  Another thread may do  synchronized  mon    mon notify         on the same mon object  and the first thread  assuming it is the only thread waiting on the monitor  will wake up    You can also call notifyAll if more than one thread is waiting on the monitor     this will wake all of them up  However  only one of the threads will be able to grab the monitor  remember that the wait is in a synchronized block  and carry on     the others will then be blocked until they can acquire the monitor s lock   Another point is that you call wait on Object itself  i e  you wait on an object s monitor  whereas you call sleep on Thread   Yet another point is that you can get spurious wakeups from wait  i e  the thread which is waiting resumes for no apparent reason   You should always wait whilst spinning on some condition as follows     synchronized       while   condition    mon wait

User · Answer

wait   is a method of Object class  sleep   is a method of Thread class  sleep   allows the thread to go to sleep state for x milliseconds   When a thread goes into sleep state it doesn   t release the lock   wait   allows thread to release the lock and goes to suspended state   This thread will be active when a notify   or notifAll   method is  called  for the same object

User · Answer

Should be called from synchronized block   wait   method is always called from synchronized block i e  wait   method needs to lock object monitor before object on which it is called   But sleep   method can be called from outside synchronized block i e  sleep   method doesn   t need any object monitor   IllegalMonitorStateException   if wait   method is called without acquiring object lock than IllegalMonitorStateException is thrown at runtime  but sleep   method never throws such exception   Belongs to which class   wait   method belongs to java lang Object class but sleep   method belongs to java lang Thread class   Called on object or thread   wait   method is called on objects but sleep   method is called on Threads not objects   Thread state   when wait   method is called on object  thread that holded object   s monitor goes from running to waiting state and can return to runnable state only when notify   or notifyAll   method is called on that object  And later thread scheduler schedules that thread to go from from runnable to running state   when sleep   is called on thread it goes from running to waiting state and can return to runnable state when sleep time is up   When called from synchronized block   when wait   method is called thread leaves the object lock   But sleep   method when called from synchronized block or method thread doesn   t leaves object lock   For More Reference

User · Answer

There are some difference key notes i conclude after working on wait and sleep  first take a look on sample using wait   and sleep     Example1  using wait   and sleep     synchronized HandObject        while isHandFree      false               Hand is still busy on happy coding or something else  please wait            HandObject wait                Get lock     It is my turn  take a cup beer now    while  beerIsAvailable      false           Beer is still coming  not available  Hand still hold glass to get beer         don t release hand to perform other task        Thread sleep 5000         Enjoy my beer now       drinkBeers        I have drink enough  now hand can continue with other task  continue coding    setHandFreeState true   synchronized HandObject        HandObject notifyAll        Let clarity some key notes    Call on    wait    Call on current thread that hold HandObject Object  sleep    Call on Thread execute task get beer  is class method so affect on current running thread   Synchronized    wait    when synchronized multi thread access same Object  HandObject   When need communication between more than one thread  thread execute coding  thread execute get beer   access on same object HandObject   sleep    when waiting condition to continue execute  Waiting beer available   Hold lock    wait    release the lock for other object have chance to execute  HandObject is free  you can do other job  sleep    keep lock for at least t times  or until interrupt   My job still not finish  i m continue hold lock and waiting some condition to continue   Wake-up condition    wait    until call notify    notifyAll   from object sleep    until at least time expire or call interrupt   And the last point is use when as estani indicate       you normally use sleep   for time-syncronization and wait   for   multi-thread-synchronization    Please correct me if i m wrong

User · Answer

I found this post helpful  It puts the difference between Thread sleep    Thread yield    and Object wait   in human terms  To quote      It all eventually makes its way down to the OS   s scheduler  which   hands out timeslices to processes and threads       sleep n  says    I   m done with my timeslice  and please don   t give me   another one for at least n milliseconds     The OS doesn   t even try to   schedule the sleeping thread until requested time has passed       yield   says    I   m done with my timeslice  but I still have work to   do     The OS is free to immediately give the thread another timeslice    or to give some other thread or process the CPU the yielding thread   just gave up       wait   says    I   m done with my timeslice  Don   t give me another   timeslice until someone calls notify       As with sleep    the OS won   t   even try to schedule your task unless someone calls notify    or one of   a few other wakeup scenarios occurs        Threads also lose the remainder of their timeslice when they perform   blocking IO and under a few other circumstances  If a thread works   through the entire timeslice  the OS forcibly takes control roughly as   if yield   had been called  so that other processes can run       You rarely need yield    but if you have a compute-heavy app with   logical task boundaries  inserting a yield   might improve system   responsiveness  at the expense of time     context switches  even just   to the OS and back  aren   t free   Measure and test against goals you   care about  as always

User · Answer

In my opinion  the main difference between both mechanisms is that sleep interrupt is the most basic way of handling threads  whereas wait notify is an abstraction aimed to do thread inter-communication easier  This means that sleep interrupt can do anything  but that this specific task is harder to do   Why is wait notify more suitable  Here are some personal considerations    It enforces centralization  It allows to coordinate the communication between a group of threads with a single shared object  This simplifies the work a lot  It enforces synchronization  Because it makes the programmer wrap the call to wait notify in a synchronized block  It s independent of the thread origin and number  With this approach you can add more threads arbitrarily without editing the other threads or keeping a track of the existing ones  If you used sleep interrupt  first you would need to keep the references to the sleeping threads  and then interrupt them one by one  by hand    An example from the real life that is good to explain this is a classic restaurant and the method that the personnel use to communicate among them  The waiters leave the customer requests in a central place  a cork board  a table  etc    ring a bell  and the workers from the kitchen come to take such requests  Once that there is any course ready  the kitchen personnel ring the bell again so that the waiters are aware and take them to the customers

User · Answer

From oracle documentation page on wait   method of Object   public final void wait      Causes the current thread to wait until another thread invokes the notify   method or the notifyAll   method for this object  In other words  this method behaves exactly as if it simply performs the call wait 0   The current thread must own this object s monitor  The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object s monitor to wake up  interrupts and spurious wakeups are possible This method should only be called by a thread that is the owner of this object s monitor   This method throws   IllegalMonitorStateException - if the current thread is not the owner of the object s monitor  InterruptedException - if any thread interrupted the current thread before or while the current thread was waiting for a notification  The interrupted status of the current thread is cleared when this exception is thrown    From oracle documentation page on sleep   method of Thread class   public static void sleep long millis     Causes the currently executing thread to sleep  temporarily cease execution  for the specified number of milliseconds  subject to the precision and accuracy of system timers and schedulers  The thread does not lose ownership of any monitors    This method throws    IllegalArgumentException - if the value of millis is negative InterruptedException - if any thread has interrupted the current thread  The interrupted status of the current thread is cleared when this exception is thrown    Other key difference   wait   is a non-static method  instance method  unlike static method sleep    class method

User · Answer

wait and sleep methods are very different    sleep has no way of  waking-up   whereas wait has a way of  waking-up  during the wait period  by another thread calling notify or notifyAll    Come to think about it  the names are confusing in that respect  however sleep is a standard name and wait is like the WaitForSingleObject or WaitForMultipleObjects in the Win API

User · Answer

wait   must surround with synchronized when the thread entry the synchronized block or method  it means get the lock so it not block invoke wait mean release the lock so it exit the synchronized then block  Thread sleep   causes the current thread to suspend execution for a specified period The thread does not lose ownership of any monitors

User · Answer

wait waits for a process to finish  sleep sleeps for a certain amount of seconds

User · Answer

From this post   http   javaconceptoftheday com difference-between-wait-and-sleep-methods-in-java   wait   Method   1  The thread which calls wait   method releases the lock it holds   2  The thread regains the lock after other threads call either notify   or notifyAll   methods on the same lock   3  wait   method must be called within the synchronized block   4  wait   method is always called on objects   5  Waiting threads can be woken up by other threads by calling notify   or notifyAll   methods   6  To call wait   method  thread must have object lock   sleep   Method  1  The thread which calls sleep   method doesn   t release the lock it holds   2  sleep   method can be called within or outside the synchronized block   3  sleep   method is always called on threads   4  Sleeping threads can not be woken up by other threads  If done so  thread will throw InterruptedException   5  To call sleep   method  thread need not to have object lock

[bash] Difference between wait and sleep

Examples related to bash

Examples related to shell

Examples related to wait

Examples related to sleep