Await can be "woken up" by another thread callingnotify on the monitor which is being waited on whereas asleep cannot. Also await (andnotify) must happen in a blocksynchronized on the monitor object whereassleep does not:

Object mon = ...;synchronized (mon) {    mon.wait();}

At this point the currently executing thread waitsand releases the monitor. Another thread may do

synchronized (mon) { mon.notify(); }

(on the samemon object) and the first thread (assuming it is the only thread waiting on the monitor) will wake up.

You can also callnotifyAll if more than one thread is waiting on the monitor – this will wakeall of them up. However, only one of the threads will be able to grab the monitor (remember that thewait is in asynchronized block) and carry on – the others will then be blocked until they can acquire the monitor's lock.

Another point is that you callwait onObject itself (i.e. you wait on an object's monitor) whereas you callsleep onThread.

Yet another point is that you can getspurious wakeups fromwait (i.e. the thread which is waiting resumes for no apparent reason). You shouldalwayswait whilst spinning on some condition as follows:

synchronized {    while (!condition) { mon.wait(); }}

One key difference not yet mentioned is that:

• sleep() doesnot 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 }

I foundthis post helpful. It puts the difference betweenThread.sleep(),Thread.yield(), andObject.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 withsleep(), the OS won’t even try to schedule your task unless someone callsnotify() (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 ifyield() had been called, so that other processes can run.

You rarely needyield(), but if you have a compute-heavy app with logical task boundaries, inserting ayield()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.

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 andnotify() == 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 usesleep() for time-syncronization andwait() 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.

Here, I have listed few important differences betweenwait() andsleep() methods.
PS:Also click on the links to see library code (internal working, just play around a bit for better understanding).

wait()

1. wait() method releases the lock.
2. wait() is the method ofObject class.
3. wait() is the non-static method -public final void wait() throws InterruptedException { //...}
4. wait() should be notified bynotify() ornotifyAll() methods.

5. wait() method needs to be called from a loop in order to deal with false alarm.

6. wait() method must be called from synchronized context (i.e. synchronized method or block), otherwise it will throwIllegalMonitorStateException

sleep()

1. sleep() method doesn't release the lock.
2. sleep() is the method ofjava.lang.Thread class.
3. sleep() is the static method -public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. after the specified amount of time,sleep() is completed.
5. sleep() better not to call from loop(i.e.see code below).
6. 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    }

Difference between wait() and sleep()

• The fundamental difference is thatwait() is non static method ofObject andsleep() is a static method ofThread.
• The major difference is thatwait() releases the lock whilesleep() doesn’t release any lock while waiting.
• wait() is used for inter-thread communication whilesleep() is used to introduce a pause on execution, generally.
• wait() should be called from inside synchronise or else we get anIllegalMonitorStateException, whilesleep() can be called anywhere.
• To start a thread again fromwait(), you have to callnotify() ornotifyAll() indefinitely. As forsleep(), the thread gets started definitely after a specified time interval.

Similarities

• Both make the current thread go into theNot Runnable state.
• Both arenative methods.

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: usingwait() andsleep():

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:

1. 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)
2. 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)
3. 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)
4. Wake-up condition:
   • wait(): until call notify(), notifyAll() from object
   • sleep(): until at least time expire or call interrupt
5. And the last point isuse when asestani indicate:

you normally use sleep() for time-syncronization and wait() for multi-thread-synchronization.

Please correct me if i'm wrong.

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 ofwait() method thread goes in waiting state and it won't come back automatically until we call thenotify() method (ornotifyAll() 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 thewait() ornotify() ornotifyAll() methods. And one more thing, thewait() 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 ofsleep() 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 anynotify() ornotifyAll() 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 thesleep() method.

And one more important difference which is asked often in interviews:sleep() belongs toThread class andwait() belongs toObject class.

These are all the differences betweensleep() andwait().

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.

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 callst.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 callt.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, likesleep(), but with a twist. Wait is called on an object, not a thread; we call this object the "lock object." Beforelock.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 calllock.notify(). This wakes up the original, waiting thread. Basically,wait()/notify() is likesleep()/interrupt(), only the active thread does not need a direct pointer to the sleeping thread, but only to the shared lock object.

Wait and sleep are two different things:

• Insleep() the thread stops working for the specified duration.
• Inwait() the thread stops working until the object being waited-on is notified, generally by other threads.

sleep is a method ofThread,wait is a method ofObject, sowait/notify is a technique of synchronizing shared data in Java (usingmonitor), butsleep is a simple method of thread to pause itself.

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

Themajor difference is thatwait() 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:diffsleep andwait

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 andsleep methods are very different:

• sleep has no way of "waking-up",
• whereaswait has a way of "waking-up" during the wait period, by another thread callingnotify ornotifyAll.

Come to think about it, the names are confusing in that respect; howeversleep is a standard name andwait is like theWaitForSingleObject orWaitForMultipleObjects in the Win API.

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.

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

1. wait() is a method ofObject class.
   sleep() is a method ofThread class.

2. sleep() allows the thread to go tosleep state for x milliseconds.
   When a thread goes into sleep stateit doesn’t release the lock.

3. wait() allows thread to release the lock andgoes to suspended state.
   This thread will be active when anotify() ornotifAll() method is called for the same object.

One potential big difference between sleep/interrupt and wait/notify is that

• callinginterrupt() duringsleep() always throws an exception (e.g.InterruptedException), whereas
• callingnotify() duringwait() 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.

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.

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 usewait 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...

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

wait releases the lock andsleep doesn't. A thread in waiting state is eligible for waking up as soon asnotify ornotifyAll is called. But in case ofsleep the thread keeps the lock and it'll only be eligible once the sleep time is over.

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.

In my opinion, the main difference between both mechanisms is that sleep/interrupt is the most basic way of handling threads, whereaswait/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:

1. 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.

2. It enforces synchronization. Because it makes the programmer wrap the call to wait/notify in a synchronized block.

3. 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.

Example about sleep doesn’t release lock and wait does

Here there are two classes :

1. Main : Contains main method and two threads.

2. 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 :nullBoth 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 nullSingletonA still nullSingletonA still null_instance :com.omt.sleepwait.Singleton@10c042abSingletonA still nullSingletonA still nullSingletonA still nullBoth 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.

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. Butsleep() method can be called from outside synchronized block i.e.sleep() method doesn’t need any object monitor.

IllegalMonitorStateException : ifwait() method is called without acquiring object lock thanIllegalMonitorStateException is thrown at runtime, butsleep() method never throws such exception.

Belongs to which class :wait() method belongs tojava.lang.Object class butsleep() method belongs tojava.lang.Thread class.

Called on object or thread :wait() method is called on objects butsleep() method is called on Threads not objects.

Thread state : whenwait() method is called on object, thread that holded object’s monitor goes from running to waiting state and can return to runnable state only whennotify() ornotifyAll() method is called on that object. And later thread scheduler schedules that thread to go from from runnable to running state. whensleep() 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 : whenwait() method is called thread leaves the object lock. Butsleep() method when called from synchronized block or method thread doesn’t leaves object lock.

For MoreReference

wait() is given inside a synchronized method whereassleep() is given inside a non-synchronized method becausewait() method release the lock on the object butsleep() oryield() does release thelock().

From oracle documentation page onwait() method ofObject:

public final void wait()

1. Causes the current thread to wait until another thread invokes thenotify() method or thenotifyAll() method for this object. In other words, this method behaves exactly as if it simply performs the callwait(0).
2. 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
3. interrupts and spurious wakeups are possible
4. This method should only be called by a thread that is the owner of this object's monitor

This method throws

1. IllegalMonitorStateException - if the current thread is not the owner of the object's monitor.

2. 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 onsleep() method ofThread class:

public static void sleep(long millis)

1. 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.
2. The thread does not lose ownership of any monitors.

This method throws:

1. IllegalArgumentException - if the value of millis is negative

2. 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 methodsleep() (class method).

• The methodwait(1000) causes the current thread to sleepup to one second.
  • A thread could sleep less than 1 second if it receives thenotify() ornotifyAll() method call.
• The call tosleep(1000) causes the current thread to sleep forexactly 1 second.
  • Alsosleeping thread doesn't hold lock any resource. But waiting thread does.

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.

• java
• multithreading
• wait
• sleep
• java-threads