Diferencia entre esperar () y dormir ()

¿Cuál es la diferencia entre wait() y sleep() en Threads?

¿Tengo entendido que un hilo wait() -ing todavía está en modo de ejecución y utiliza ciclos de CPU, pero un sleep() -ing no consume ningún ciclo de CPU correcto?

¿Por qué tenemos tanto wait() como sleep() : ¿cómo varía su implementación en un nivel inferior?

Una wait puede ser “despertado” por otro hilo llamando a notify en el monitor que está esperando mientras que un sleep no puede. También debe producirse una wait (y notify ) en un bloque synchronized en el objeto del monitor, mientras que el sleep no:

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

En este punto, el hilo que se está ejecutando espera y libera el monitor . Otro hilo puede hacer

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

(En el mismo objeto mon ) y el primer subproceso (asumiendo que es el único subproceso que espera en el monitor) se activará.

También puede llamar a notifyAll si hay más de un hilo esperando en el monitor, esto los despertará a todos . Sin embargo, solo uno de los hilos podrá agarrar el monitor (recuerde que la wait encuentra en un bloque synchronized ) y continuar; los otros serán bloqueados hasta que puedan adquirir el locking del monitor.

Otro punto es que usted llama a wait en el Object mismo (es decir, espera en el monitor de un objeto) mientras que usted llama a wait en el Thread .

Sin embargo, otro punto es que puedes wait de una wait espuria (es decir, el hilo que está esperando se reanuda sin motivo aparente). Siempre debe wait mientras gira en alguna condición de la siguiente manera:

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

Una diferencia clave que aún no se menciona es que, mientras duerme, un subproceso no libera los lockings que contiene, mientras espera libera el locking en el objeto al que se llama wait() .

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

Encontré este enlace útil (que hace referencia a esta publicación ). Pone la diferencia entre sleep() , wait() y yield() en términos humanos. (en caso de que los enlaces se agoten, he incluido la publicación a continuación con marcado adicional)

Finalmente, todo hace su camino hasta el progtwigdor del sistema operativo, que distribuye las partes del tiempo a los procesos y los hilos.

sleep(n) dice “He terminado mi timeslice, y por favor no me proporciones otro por al menos n milisegundos”. El sistema operativo ni siquiera intenta progtwigr el hilo de dormir hasta que el tiempo solicitado haya pasado.

yield() dice “He terminado mi timeslice, pero todavía tengo trabajo por hacer”. El sistema operativo es libre de darle inmediatamente al thread otro timeslice, o de darle algún otro thread o procesar el CPU, el hilo que cede acaba de abandonar. .

.wait() dice “He terminado con mi timeslice. No me dé otro timeslice hasta que alguien llame a notify (). “ Al igual que con sleep() , el sistema operativo ni siquiera intentará progtwigr su tarea a menos que alguien llame a notify() (o se produzca uno de los pocos escenarios de activación).

Los subprocesos también pierden el rest de sus tiempos de espera cuando realizan lockings de E / S y en algunas otras circunstancias. Si un hilo funciona a través del intervalo de tiempo completo, el sistema operativo toma el control aproximadamente como si se hubiera llamado a yield() , para que se puedan ejecutar otros procesos.

Raramente necesita yield() , pero si tiene una aplicación de cálculo pesado con límites de tareas lógicas, insertar un yield() podría mejorar la capacidad de respuesta del sistema (a expensas del tiempo, los cambios de contexto, incluso solo para el sistema operativo y viceversa, aren ‘ t gratis). Mide y prueba contra los objectives que te interesan, como siempre.

Aquí hay muchas respuestas, pero no pude encontrar la distinción semántica mencionada en ninguna.

No se trata del hilo en sí mismo; Ambos métodos son necesarios ya que admiten casos de uso muy diferentes.

sleep() envía el Thread para que duerma como estaba antes, simplemente empaqueta el contexto y deja de ejecutarse durante un tiempo predefinido. Entonces, para despertarlo antes del tiempo debido, necesita conocer la referencia del hilo. Esta no es una situación común en un entorno de subprocesos múltiples. Se utiliza principalmente para sincronizar el tiempo (p. Ej., Despertar en exactamente 3,5 segundos) y / o equidad codificada (simplemente duerma un rato y deje que otros hilos funcionen).

wait() , por el contrario, es un mecanismo de sincronización de subprocesos (o mensajes) que le permite notificar a un subproceso del que no tiene referencia almacenada (ni le importa). Puede pensarlo como un patrón de publicación y suscripción ( wait == subscribe y notify() == publish). Básicamente, utilizando notify () está enviando un mensaje (que incluso podría no recibirse y normalmente no le importa).

Para resumir, normalmente usa sleep() para sincronización de tiempo y wait() para sincronización de subprocesos múltiples.

Podrían implementarse de la misma manera en el sistema operativo subyacente, o no funcionar (ya que las versiones anteriores de Java no tenían multiprocesamiento real, probablemente algunas máquinas virtuales pequeñas tampoco lo hacen). No se olvide de que Java se ejecuta en una VM, por lo que su código se transformará en algo diferente según la VM / OS / HW en la que se ejecute.

Aquí, he enumerado algunas diferencias importantes entre los métodos wait() y sleep() .
PD: También haga clic en los enlaces para ver el código de la biblioteca (trabajo interno, simplemente juegue un poco para una mejor comprensión).

Espere()

  1. wait() método wait() libera el locking.
  2. wait() es el método de la clase Object .
  3. wait() es el método no estático – public final void wait() throws InterruptedException { //...}
  4. wait() debe ser notificado por notify() métodos notifyAll() o notifyAll() .
  5. wait() método wait() necesita ser llamado desde un bucle para poder manejar la falsa alarma.

  6. wait() método wait() debe IllegalMonitorStateException desde el contexto sincronizado (es decir, el método o el bloque sincronizados); de lo contrario, lanzará IllegalMonitorStateException

dormir()

  1. sleep() método sleep() no libera el locking.
  2. sleep() es el método de la clase java.lang.Thread .
  3. sleep() es el método estático – public static void sleep(long millis, int nanos) throws InterruptedException { //... }
  4. después de la cantidad de tiempo especificada, se completa sleep() .
  5. sleep() mejor no llamar desde loop (es decir, ver el código a continuación ).
  6. sleep() se puede llamar desde cualquier lugar. no hay un requisito específico.

Ref .: Diferencia entre esperar y dormir

Fragmento de código para llamar al método de espera y suspensión

 synchronized(monitor){ while(condition == true){ monitor.wait() //releases monitor lock } Thread.sleep(100); //puts current thread on Sleep } 

transición de hilos a diferentes estados de hilos

Hay algunas notas clave de diferencia que concluyo después de trabajar en esperar y dormir, primero eche un vistazo a la muestra usando wait () y sleep ():

Ejemplo 1 : usando wait () y 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(); } 

Deje que la claridad algunas notas clave:

  1. Llamar a :
    • wait (): invocar el hilo actual que contiene el Objeto HandObject
    • sleep (): Call on Thread ejecuta la tarea get beer (es un método de clase así que afecta al hilo en ejecución)
  2. Sincronizado :
    • wait (): cuando se sincroniza el acceso a múltiples hilos del mismo objeto (HandObject) (cuando se necesita comunicación entre más de un hilo (thread ejecuta encoding, thread ejecuta get beer) accede al mismo objeto HandObject)
    • sleep (): cuando se espera la condición para continuar la ejecución (Waiting beer available)
  3. Mantener el locking :
    • wait (): libera el locking para que otro objeto tenga chance de ejecutarse (HandObject es gratis, puedes hacer otro trabajo)
    • sleep (): mantenga el locking al menos t veces (o hasta que se interrumpa) (Mi trabajo aún no finaliza, sigo manteniendo el locking y esperando alguna condición para continuar)
  4. Condición de despertador :
    • wait (): hasta llamar a notify (), notifyAll () desde el objeto
    • sleep (): hasta que al menos el tiempo expire o call interrupt
  5. Y el último punto es usar cuando como indican:

normalmente usa sleep () para sincronización de tiempo y wait () para sincronización de subprocesos múltiples.

Por favor corrígeme si estoy equivocado.

Diferencia entre esperar () y dormir ()

  • La diferencia fundamental es wait() es de Object y sleep() es el método estático de Thread .

  • La principal diferencia es que wait() libera el locking mientras sleep() no libera ningún locking mientras espera.

  • El wait() se utiliza para la comunicación entre hilos mientras que el sleep() se utiliza para introducir una pausa en la ejecución, en general.

  • El wait() debería llamar desde el interior para sincronizar o de lo contrario obtendremos IllegalMonitorStateException mientras sleep() pueda llamar a cualquier parte.

  • Para iniciar el hilo nuevamente desde wait() , debe llamar notify() notifyAll() o notifyAll() . Mientras está en sleep(), subproceso se inicia después del intervalo especificado de ms / seg.

Similitudes que ayudan a entender

  • Ambos hacen que el hilo actual entre en el estado No ejecutable .
  • Ambos son métodos native .

Esta es una pregunta muy simple, porque ambos métodos tienen un uso totalmente diferente.

La principal diferencia es esperar para liberar el candado o monitor mientras Sleep no suelta ningún candado o monitor mientras espera. Wait se utiliza para la comunicación entre hilos mientras que Sleep se usa para introducir pausa en la ejecución.

Esta fue solo una explicación clara y básica, si quieres más que eso, continúa leyendo.

En caso de wait() hilo del método entra en estado de espera y no volverá automáticamente hasta que llamemos al método notifyAll() (o notifyAll() si tiene más de un hilo en estado de espera y desea reactivar todos esos hilos). Y necesita locking sincronizado u objeto o locking de clase para acceder a los métodos notifyAll() o notifyAll() o notifyAll() . Y una cosa más, el método wait() se utiliza para la comunicación entre hilos porque si un hilo entra en estado de espera, necesitará otro hilo para activar dicho hilo.

Pero en caso de sleep() este es un método que se utiliza para mantener el proceso durante unos segundos o el tiempo que deseaba. Porque no necesita provocar ningún método notifyAll() o notifyAll() para recuperar ese hilo. O no necesita ningún otro hilo para recuperar ese hilo. Como si quisieras que algo suceda después de unos segundos, como en un juego después del turno del usuario, quieres que el usuario espere hasta que la computadora se reproduzca, entonces puedes mencionar el método sleep() .

Y una diferencia más importante que se pregunta a menudo en las entrevistas: sleep() pertenece a la clase Thread y wait() pertenece a la clase Object .

Estas son todas las diferencias entre sleep() y wait() .

Y existe una similitud entre ambos métodos: ambos son enunciados verificados, por lo que es necesario intentar capturar o lanzar para acceder a estos métodos.

Espero que esto ayude.

fuente: http://www.jguru.com/faq/view.jsp?EID=47127

Thread.sleep() envía el hilo actual al estado “No ejecutable” durante un cierto tiempo. El hilo mantiene los monitores que ha adquirido, es decir, si el hilo está actualmente en un bloque o método sincronizado, ningún otro hilo puede ingresar a este bloque o método. Si otro hilo llama a t.interrupt() se activará el hilo que duerme.

Tenga en cuenta que dormir es un método estático, lo que significa que siempre afecta al hilo actual (el que está ejecutando el método de suspensión). Un error común es llamar a t.sleep() donde t es un hilo diferente; incluso entonces, es el hilo actual el que duerme, no el hilo t.

t.suspend() está en desuso. Usarlo es posible detener un hilo que no sea el hilo actual. Un hilo suspendido mantiene todos sus monitores y, dado que este estado no es interrumpible, es propenso a interlocking.

object.wait() envía el hilo actual al estado “No ejecutable” , como sleep() , pero con un giro. Esperar es invocado en un objeto, no en un hilo; llamamos a este objeto el “objeto de locking”. Antes de lock.wait() , el hilo actual debe sincronizarse en el objeto de locking; wait() luego libera este locking y agrega el hilo a la “lista de espera” asociada con el locking. Más tarde, otro subproceso se puede sincronizar en el mismo objeto de locking y llamar a lock.notify() . Esto despierta el hilo original de espera. Básicamente, wait() / notify() es como sleep() / interrupt() , solo el hilo activo no necesita un puntero directo al hilo que duerme, sino solo al objeto de locking compartido.

Esperar y dormir son dos cosas diferentes:

  • En sleep() el hilo deja de funcionar durante la duración especificada.
  • En wait() el hilo deja de funcionar hasta que se notifica el objeto que se espera, generalmente por otros hilos.

sleep es un método de Thread , wait es un método de Object , por lo que wait/notify es una técnica de sincronización de datos compartidos en Java (usando monitor ), pero sleep es un método simple de thread para pausarse.

sleep () es un método que se utiliza para mantener el proceso durante unos segundos o el tiempo que quería, pero en caso de esperar () el hilo del método entra en estado de espera y no volverá automáticamente hasta que llamemos a notify () o notifyAll ().

La principal diferencia es que wait () libera el locking o monitor mientras que sleep () no libera ningún locking o monitor mientras espera. La espera se utiliza para la comunicación entre hilos mientras que el sueño se utiliza para introducir una pausa en la ejecución, en general.

Thread.sleep () envía el hilo actual al estado “No ejecutable” durante un cierto tiempo. El hilo mantiene los monitores que ha adquirido, es decir, si el hilo se encuentra actualmente en un bloque o método sincronizado, ningún otro hilo puede ingresar a este bloque o método. Si otro hilo llama a t.interrupt (), se activará el hilo que duerme. Tenga en cuenta que dormir es un método estático, lo que significa que siempre afecta al hilo actual (el que está ejecutando el método de suspensión). Un error común es llamar a t.sleep () donde t es un hilo diferente; incluso entonces, es el hilo actual el que duerme, no el hilo t.

object.wait () envía el hilo actual al estado “No ejecutable”, como sleep (), pero con un giro. Esperar es invocado en un objeto, no en un hilo; llamamos a este objeto el “objeto de locking”. Antes de llamar a lock.wait (), el hilo actual debe sincronizarse en el objeto de locking; wait () luego libera este locking y agrega el hilo a la “lista de espera” asociada con el locking. Más tarde, otro subproceso se puede sincronizar en el mismo objeto de locking y llamar a lock.notify (). Esto despierta el hilo original de espera. Básicamente, wait () / notify () es como sleep () / interrupt (), solo el hilo activo no necesita un puntero directo al hilo que duerme, sino solo al objeto de locking compartido.

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

Deje categorizar todos los puntos anteriores:

Call on:

  • wait (): llama a un objeto; el hilo actual debe sincronizarse en el objeto de locking.
  • sleep (): Call on a Thread; siempre está ejecutando thread.

Synchronized:

  • wait (): cuando varios subprocesos sincronizados acceden al mismo objeto uno por uno.
  • sleep (): cuando se sincronizan varios subprocesos, se espera a que duerma el hilo que duerme.

Hold lock:

  • wait (): libera el locking para que otros objetos tengan la oportunidad de ejecutarse.
  • sleep (): mantenga el locking al menos t veces si se especifica el tiempo de espera o si alguien interrumpe.

Wake-up condition:

  • wait (): hasta llamar a notify (), notifyAll () desde el objeto
  • sleep (): hasta que caduque al menos el tiempo o call interrupt ().

Usage:

  • sleep (): para la sincronización de tiempo y;
  • wait (): para sincronización de hilos múltiples.

Ref: diff sleep y wait

sleep métodos de wait y sleep son muy diferentes:

  • sleep no tiene forma de “despertar”,
  • mientras que wait tiene una forma de “despertarse” durante el período de espera, por otro hilo llamando notify notifyAll o notifyAll .

Ahora que lo pienso, los nombres son confusos en ese sentido; sin embargo, sleep es un nombre estándar y wait es como WaitForSingleObject o WaitForMultipleObjects en Win API.

En palabras simples, esperar es esperar hasta que otro hilo lo invoca, mientras que el sueño es “no ejecutar el siguiente enunciado” durante un período específico de tiempo.

Además, sleep es un método estático en la clase Thread y opera en thread, mientras que wait () está en la clase Object y se invoca a un objeto.

Otro punto, cuando llamas a esperar en algún objeto, el hilo implica sincronizar el objeto y luego espera. 🙂

De esta publicación: http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

Método wait ()

1) El hilo que llama al método wait () libera el locking que contiene.

2) El hilo recupera el locking después de que otros hilos invoquen los métodos notify () o notifyAll () en el mismo locking.

3) se debe llamar al método wait () dentro del bloque sincronizado.

4) el método wait () siempre se llama a los objetos.

5) Los subprocesos en espera pueden ser activados por otros subprocesos llamando a los métodos notify () o notifyAll ().

6) Para llamar al método wait (), el hilo debe tener locking de objeto.

Método sleep ()

1) El hilo que llama al método sleep () no libera el locking que contiene.

2) el método sleep () se puede llamar dentro o fuera del bloque sincronizado.

3) el método sleep () siempre se llama a los hilos.

4) Los hilos dormidos no pueden ser despertados por otros hilos. Si lo hace, thread lanzará InterruptedException.

5) Para llamar al método sleep (), thread no necesita tener locking de objeto.

dormir

  • Hace que el hilo de ejecución actual duerma durante un tiempo específico.
  • Su precisión depende de los temporizadores y planificadores del sistema.
  • Mantiene los monitores que ha adquirido, por lo que si se llama desde un contexto sincronizado, ningún otro hilo puede ingresar a ese bloque o método.
  • Si llamamos al método interrupt (), se activará el hilo que duerme.

Espere

  • Hace que el hilo actual espere hasta que otro hilo invoque el método notify () o el método notifyAll () para este objeto
  • Debe invocarse desde un contexto sincronizado, es decir, desde un bloque o método. Significa que antes de invocar el método wait (), el hilo actual debe tener bloqueado ese objeto.
  • Libera el locking en el objeto al que se llama y se agrega a la lista de espera, por lo que otro hilo puede adquirir el locking en el objeto.
  1. wait() es un método de la clase Object .
    sleep() es un método de la clase Thread .

  2. sleep() permite que el subproceso pase al estado de sleep durante x milisegundos.
    Cuando un hilo entra en estado de suspensión it doesn't release the lock .

  3. wait() permite que thread libere el locking y goes to suspended state .
    Este hilo estará activo cuando se notifAll() método notifAll() o notifAll() para el mismo objeto.

Una gran diferencia potencial entre dormir / interrumpir y esperar / notificar es que

  • calling interrupt() durante sleep() siempre arroja una excepción (por ejemplo, InterruptedException ), mientras que
  • llamar a notify() durante wait() no.

Generar una excepción cuando no se necesita es ineficiente. Si tiene hilos que se comunican entre sí a gran velocidad, generaría muchas excepciones si llamara constantemente a la interrupción, lo cual es una pérdida total de CPU.

Está en lo cierto: Sleep () hace que el hilo “duerma” y la CPU se apagará y procesará otros hilos (también conocidos como cambio de contexto) cuando yo creo que Wait mantiene el procesador de la CPU en el hilo actual.

Tenemos ambos porque, aunque puede parecer sensato dejar que otras personas usen la CPU mientras no la usas, en realidad hay una sobrecarga para cambiar el contexto. Dependiendo de cuánto duerma, puede ser más costoso en ciclos de CPU. para cambiar los hilos de lo que es simplemente hacer que su hilo no haga nada durante unos pocos ms.

También tenga en cuenta que dormir fuerza un cambio de contexto.

Además, en general no es posible controlar el cambio de contexto, durante el Wait el sistema operativo puede (y espera más tiempo) elegir procesar otros hilos.

Los métodos se usan para diferentes cosas.

 Thread.sleep(5000); // Wait until the time has passed. Object.wait(); // Wait until some other thread tells me to wake up. 

Thread.sleep (n) se puede interrumpir, pero se debe notificar a Object.wait (). Es posible especificar el tiempo máximo de espera: Object.wait(5000) por lo que sería posible usar wait to, er, sleep pero luego tiene que molestarse con lockings.

Ninguno de los métodos usa la CPU mientras duerme / espera.

Los métodos se implementan usando código nativo, utilizando construcciones similares pero no de la misma manera.

Búscate: ¿está disponible el código fuente de métodos nativos? El archivo /src/share/vm/prims/jvm.cpp es el punto de partida …

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…

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.

Por ejemplo:

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

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, 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:

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

y

 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.

Should be called from synchronized block : wait() method is always called from synchronized block ie wait() method needs to lock object monitor before object on which it is called. But sleep() method can be called from outside synchronized block ie 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

From oracle documentation page on wait() method of Object :

 public final void wait() 
  1. 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) .
  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

Este método arroja

  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 on sleep() method of Thread 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 method sleep() (class method).

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

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