Difference between "wait()" vs "sleep()" in Java

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(); }
}

One key difference not yet mentioned is that:

• sleep() does not release the lock it holds on the Thread,

  synchronized(LOCK) {
      Thread.sleep(1000); // LOCK is held
  }
  

• wait() releases the lock it holds on the object.

   synchronized(LOCK) {
       LOCK.wait(); // LOCK is not held
   }
  

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.

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. :)

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.

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.

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.

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