Distinction between Wait and Sleep, Yield in Java? Instance


The distinction between wait and sleep or the distinction between sleep and yield in Java is among the fashionable core Java interview questions and requested on multi-threading interviews. Out of three strategies that can be utilized to pause a thread in Java, sleep() and yield() strategies are outlined in thread class whereas wait() is outlined within the Object class, which is one other interview query. The important thing distinction between wait() and sleep() is that the previous is used for inter-thread communication whereas later is used to launched to pause the present thread for a brief length. This distinction is extra apparent from the truth that, when a thread calls the wait() technique, it releases the monitor or lock it was holding on that object, however when a thread calls the sleep() technique, it by no means releases the monitor even whether it is holding. 

Coming again to yield(), it is little completely different than wait() and sleep(), it simply releases the CPU maintain by Thread to present one other thread a chance to run although it isn’t assured who will get the CPU.

It completely relies upon upon thread scheduler and it is even doable that the thread which calls the yield() technique will get the CPU once more. Therefore, it isn’t dependable to depend on the yield() technique, it is simply on one of the best effort foundation.

Wait vs Sleep vs Yield in Java

On this Java tutorial, we’ll study what’s sleep in Java, essential factors of sleep in java and the distinction between Wait and sleep in Java.

Distinction between Wait and Sleep in Java

The primary distinction between wait and sleep is that wait() technique releases the acquired monitor when the thread is ready whereas Thread.sleep() technique retains the lock or monitor even when the thread is ready. Additionally, anticipate the tactic in Java needs to be referred to as from a synchronized technique or block whereas there isn’t a such requirement for sleep() technique. 

One other distinction is Thread.sleep() technique is a static technique and applies on the present thread, whereas
wait() is an instance-specific technique and solely obtained get up if another thread calls notify technique on the identical object. 

Additionally, within the case of sleep, sleeping thread instantly goes to Runnable state after waking up whereas within the case of wait, ready for a thread first acquires the lock after which goes into Runnable state. So based mostly upon your want, if you wish to pause a thread for a specified length then use the sleep() technique, and if you wish to implement inter-thread communication use the wait technique.

Right here is the record of distinction between wait and sleep in Java :

1) wait is known as from synchronized context solely whereas sleep could be referred to as with out synchronized block. see Why to attend and notify must name from the synchronized technique for extra element.

2) ready thread could be awake by calling notify and notifyAll whereas sleeping thread cannot be woke up by calling notify technique.

3) wait is generally finished on the situation, Thread waits till a situation is true whereas sleep is simply to place your thread on sleep.

4) anticipate launch lock on an object whereas ready whereas sleep doesn’t launch the lock whereas ready.

5) The wait() technique is known as on an object on which the synchronized block is locked, whereas sleep is known as on the Thread. See these Java Multithreading programs for extra particulars on find out how to use wait() and notify technique in Java. 

And, when you prefer to see variations in tabular format for higher understanding, here’s a good desk which which highlights all variations between wait(), sleep(), and yield() technique in Java:

Difference between Wait and Sleep, Yield in Java? Example

Distinction between yield and sleep in Java

The most important distinction between yield and sleep in Java is that yield() technique pauses the at present executing thread quickly for giving an opportunity to the remaining ready threads of the identical precedence to execute. If there isn’t a ready thread or all of the ready threads have a decrease precedence then the identical thread will proceed its execution. 

The yielded thread when it should get the prospect for execution is determined by the thread scheduler whose conduct is vendor dependent. Yield technique doesn’t assure that the present thread will pause or cease nevertheless it ensures that CPU can be relinquished by present Thread on account of a name to Thread.yield() technique in java. See Java Concurrency in Observe for extra particulars. 

Sleep technique in Java has two variants one which takes millisecond as sleeping time whereas others which takes each mill and nanosecond for the sleeping length.

sleep(lengthy millis)


sleep(lengthy millis,int nanos)

Causes the at present executing thread to sleep for the required variety of milliseconds plus the required variety of nanoseconds.

Right here is sweet diagram which reveals how thread transition occur to completely different thread states by calling the wait(), sleep() and yield() strategies.

Difference between wait() and sleep() method in threading java

Instance of Thread.sleep() technique in Java

Here’s a pattern code instance of Sleep Thread in Java. On this instance, now we have put the Essential thread in Sleep for 1 second.


 * Instance of Thread Sleep technique in Java


public class SleepTest {


       public static void predominant(String… args){

              System.out.println(Thread.currentThread().getName() + ” goes to sleep for 1 Second”);

              attempt {


              } catch (InterruptedException e) {

                     // TODO Auto-generated catch block



              System.out.println(“Essential Thread is woken now”);




predominant goes to sleep for 1 Second

Essential Thread is woken now

10 factors about Thread sleep() technique in Java

difference between sleep, wait and yield in Java exampleI’ve listed down some essential and price to recollect factors about Sleep() technique of Thread Class in Java:

1) Thread.sleep() technique is used to pause the execution, relinquish the CPU and return it to string scheduler.

2) Thread.The sleep() technique is a static technique and at all times places the present thread to sleep.

3) Java has two variants of sleep technique in Thread class one with one argument which takes milliseconds because the length of sleep and one other technique with two arguments one is millisecond and different is the nanosecond.

4) In contrast to wait() technique in Java, sleep() technique of Thread class does not relinquish the lock it has acquired.

5) sleep() technique throws Interrupted Exception if one other thread interrupts a sleeping thread in java.

6) With sleep() in Java it isn’t assured that when sleeping thread awakened it should undoubtedly get CPU, as a substitute it should go to Runnable state and struggle for CPU with different thread.

7) There’s a false impression about sleep technique in Java that calling t.sleep() will put Thread “t” into sleeping state, that is not true as a result of Thread.sleep technique is a static technique it at all times put the present thread into Sleeping state and never thread “t”.

That’s all on Sleep technique in Java. We now have seen the distinction between sleep and wait together with sleep and yield in Java. In Abstract, simply take into account that each sleep() and yield() function on the present thread.

Java Tutorial you could like:


Leave a Reply

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