Diferencia entre wait () y sleep()

Una diferencia clave aún no mencionada es que mientras se duerme un Hilo no libera los bloqueos que sostiene, mientras espera libera el bloqueo en el objeto que wait() es invocado.

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


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

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

Todo finalmente se abre camino hasta el programador del sistema operativo, que reparte timeslices a procesos e hilos.

sleep(n) dice "He terminado con mi timeslice, y por favor no me des otro uno durante al menos n milisegundos." El sistema operativo ni siquiera intenta programe el hilo para dormir hasta que haya pasado el tiempo solicitado.

yield() dice "he terminado con mi timeslice, pero todavía tengo trabajo que hacer." El sistema operativo es libre de dar inmediatamente al hilo otro timeslice, o para dar algún otro hilo o procesar la CPU el hilo de rendimiento simplemente se rindió.

.wait() dice "he terminado con mi timeslice. No me des otra. timeslice hasta que alguien llame a notify ()." Al igual que con sleep(), el sistema operativo no incluso trate de programar su tarea a menos que alguien llame notify() (o uno de algunos otros escenarios de despertar ocurren).

Los hilos también pierden el resto de su intervalo de tiempo cuando realizan bloqueando IO y bajo algunas otras circunstancias. Si un hilo funciona a través de todo el timeslice, el sistema operativo toma el control a la fuerza más o menos como si yield() ha sido llamado, para que otros procesos puedan ejecutarse.

Rara vez se necesita yield(), pero si usted tiene una aplicación de computación pesada con límites lógicos de la tarea, insertando un yield() podría mejorar el sistema capacidad de respuesta (a expensas de los cambios de contexto de tiempo, incluso solo para el sistema operativo y la espalda, no son libres). Mida y pruebe sus objetivos me importa, como siempre.

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

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

sleep() envía el Hilo al modo de espera como estaba antes, solo empaqueta el contexto y deja de ejecutarse durante un tiempo predefinido. Así que para despertarlo antes del tiempo debido, necesita saber la referencia del hilo. Esta no es una situación común en un entorno multihilo. Se usa principalmente para sincronización de tiempo (por ejemplo, despertar en exactamente 3.5 segundos) y/o equidad codificada (solo duerme por un tiempo y deja que otros hilos funcionen).

wait(), por el contrario, es un mecanismo de sincronización de hilo (o mensaje) que le permite notificar un Hilo del que no tiene ninguna referencia almacenada (ni cuidado). Puedes considerarlo como un patrón publicar-suscribirse (wait = = suscribirse y notify() = = publicar). Básicamente usando notify() estás enviando un mensaje (que podría incluso no ser recibido en absoluto y normalmente no te importa).

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

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

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

Espera()

1. wait() el método libera el bloqueo.
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() o notifyAll() método.

5. wait() el método necesita ser llamado desde un bucle para tratar con falsas alarmas.

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

Dormir()

1. sleep() el método no libera el bloqueo.
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 especificada de tiempo, sleep() se ha completado.
5. sleep() mejor no llamar desde bucle(es decir, ver el código a continuación).
6. sleep() se puede llamar desde cualquier lugar. no hay ningún requisito específico.

Ref: Diferencia entre Esperar y Dormir

Fragmento de código para llamar al método wait y sleep

synchronized(monitor){
    while(condition == true){ 
        monitor.wait()  //releases monitor lock
    }

    Thread.sleep(100); //puts current thread on Sleep    
}

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

Example1 : 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 claridad algunas notas clave:

1. Llame a:
   • wait(): Llama al hilo actual que contiene el objeto HandObject
   • sleep (): Llama al hilo ejecutar tarea get beer (es un método de clase que afecta al funcionamiento actual thread)
2. Sincronizado :
   • wait (): cuando se sincroniza multi hilo de acceso mismo objeto (HandObject) (Cuando se necesita comunicación entre más de un hilo (hilo ejecutar codificación, hilo ejecutar obtener cerveza) acceso en el mismo objeto HandObject )
   • sleep (): cuando la condición de espera para continuar ejecutar (Cerveza de espera disponible)
3. Mantenga el bloqueo :
   • wait (): libera el bloqueo para que otro objeto tenga la posibilidad de ejecutar (HandObject es gratis, puedes hacer otro trabajo)
   • sleep (): mantener el bloqueo por lo menos t veces (o hasta la interrupción) (Mi trabajo todavía no termina, estoy continuar mantenga el bloqueo y esperando alguna condición para continuar)
4. Condición de despertar:
   • wait(): until call notify(), notifyAll() from object
   • sleep(): hasta que al menos el tiempo expire o interrumpa la llamada
5. Y el último punto es use cuando como estani indíquese:

Normalmente se usa sleep () para sincronización de tiempo y wait () para multi-thread-sincronización.

Por favor corríjame si me equivoco.

Diferencia entre wait() y sleep()

• 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 bloqueo mientras que sleep() no relea ningún bloqueo mientras espera.

• El wait() se usa para la comunicación entre subprocesos, mientras que sleep() se usa para introducir una pausa en la ejecución, generalmente.

• El wait() debe llamar desde dentro sincronice o de lo contrario obtenemos IllegalMonitorStateException mientras que sleep() puede llamar a cualquier lugar.

• Para iniciar el hilo de nuevo desde wait(), tienes que llamar a notify() o notifyAll(). Mientras que en sleep(), el hilo se inicia después del intervalo ms/seg especificado.

Similitudes que ayudan a entender

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

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

La principal diferencia es esperar para liberar el bloqueo o el monitor mientras el sueño no libera ningún bloqueo o monitor mientras espera. Wait se utiliza para la comunicación entre hilos, mientras que sleep se utiliza para introducir la 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 el caso de wait() hilo de método va en estado de espera y no volverá automáticamente hasta que llamemos al método notify() (o notifyAll() si tiene más de un hilo en estado de espera y desea activar todos esos hilos). Y necesita sincronizado o bloqueo de objeto o bloqueo de clase para acceder a los métodos wait() o notify() o notifyAll(). Y una cosa más, el método wait() se utiliza para la comunicación entre hilos porque si un hilo va en estado de espera necesitará otro hilo para despertar ese 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 quería. Porque no necesitas provocar ningún método notify() o notifyAll() para recuperar ese hilo. O no necesitas ningún otro hilo para llamar a ese hilo. Al igual que si desea que algo debe suceder después de unos segundos como en un juego después del turno del usuario desea que el usuario espere hasta que el equipo juega entonces usted puede mencionar el método sleep().

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

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

Y hay una similitud entre ambos métodos: ambos son sentencias verificadas, por lo que necesita probar catch o throws para acceder a estos métodos.

Espero que esto te ayude.

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

Thread.sleep() envía el subproceso actual al estado "No ejecutable" por algún 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 entrar en este bloque o método. Si otro hilo llama t.interrupt() despertará el hilo para dormir.

Tenga en cuenta que el sueño es una estática método, lo que significa que siempre afecta el hilo actual (el que está ejecutando el método sleep). Un error común es llamar t.sleep() donde t es un hilo diferente; incluso entonces, es el hilo actual el que dormirá, no el hilo t.

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

object.wait() envía el subproceso actual al estado "No ejecutable" , como sleep(), pero con un giro. Wait se llama en un objeto, no en un thread; llamamos a este objeto el " lock object."Antes de lock.wait() es llamado, el hilo actual debe sincronizarse en el objeto lock; wait() luego libera este bloqueo y agrega el hilo a la " lista de espera" asociado con la cerradura. Más tarde, otro hilo puede sincronizar en el mismo objeto de bloqueo y llamada lock.notify(). Esto despierta el original, esperando hilo. Básicamente, wait()/notify() es como sleep()/interrupt(), solo el hilo activo no necesita un directo puntero al hilo en reposo, pero solo al objeto de bloqueo compartido.

Esperar y dormir son dos cosas diferentes:

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

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 hilo para pausarse.

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

La diferencia mayor es que wait() libera el bloqueo o monitor mientras que sleep() no libera ningún bloqueo o monitor mientras espera. Wait se usa para la comunicación entre hilos, mientras que sleep se usa para introducir pause en la ejecución, generalmente.

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

Objeto.wait () envía el hilo actual al estado "No ejecutable", como sleep (), pero con un giro. Wait se llama a un objeto, no a un hilo; llamamos a este objeto el "objeto de bloqueo."Antes de cerrar.wait() se llama, el subproceso actual debe sincronizarse en el objeto lock; wait () luego libera este bloqueo, y agrega hilo a la "lista de espera" asociado con el bloqueo. Más tarde, otro hilo puede sincronizarse en el mismo objeto lock y call lock.notificar(). Esto despierta el hilo original, esperando. Básicamente, wait()/notify() es como sleep()/interrupt (), solo que el subproceso activo no necesita un puntero directo al subproceso durmiente, sino solo al objeto de bloqueo compartido.

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

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

Vamos a categorizar todos los puntos anteriores:

Call on:

• wait (): Llamar a un objeto; hilo actual debe sincronizarse en el objeto de bloqueo.
• sleep (): Llama a un subproceso; siempre ejecutando el subproceso.

Synchronized:

• wait(): cuando se sincronizan varios subprocesos acceden al mismo objeto uno por uno.
• sleep(): cuando se sincronizan varios hilos, espere a que se termine el sueño del hilo de dormir.

Hold lock:

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

Wake-up condition:

• wait (): until call notify(), notifyAll() from object
• sleep (): hasta que al menos expire el tiempo o se interrumpa la llamada().

Usage:

• sleep (): para sincronización de tiempo y;
• wait (): for multi-thread-sincronización.

Ref:diff sleep y wait

wait y sleep los métodos son muy diferentes:

• sleep no tiene forma de "despertar",
• considerando wait tiene una forma de" despertar " durante el período de espera, por otro hilo llamando notify 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 el WaitForSingleObject o WaitForMultipleObjects en la API de Win.

En palabras simples, wait es wait Hasta que algún otro hilo te invoque mientras que sleep es "dont execute next statement" por algún período de tiempo especificado.

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 llama a un objeto.

Otro punto, cuando se llama a wait en algún objeto, el hilo involucrado sincroniza el objeto y luego espera. :)

De este post: 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 bloqueo que contiene.

2) El subproceso recupera el bloqueo después de que otros subprocesos llamen a los métodos notify() o notifyAll() en el mismo bloqueo.

3) el método wait() debe ser llamado dentro del bloque sincronizado.

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

5) Esperando los hilos pueden ser despertados por otros hilos llamando a los métodos notify() o notifyAll ().

6) Para llamar al método wait (), el hilo debe tener object lock.

Método Sleep ()

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

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

3) el método sleep() siempre se llama en subprocesos.

4) Los hilos de dormir no pueden ser despertados por otros hilos. Si lo hace, hilo lanzará una excepción interrumpida.

5) Para llamar al método sleep (), thread no necesita tener object lock.

Dormir

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

Espera

• Causa corriente hilo a esperar hasta que otro hilo invoque el método notify() o el método notifyAll () para este objeto
• Se debe llamar desde un contexto sincronizado, es decir, desde un bloque o method.It significa que antes de llamar al método wait (), el hilo actual debe fije ese objeto.
• Libera lock en el objeto en el que se llama y se agrega a lista de espera, por lo que otro hilo puede adquirir bloqueo 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 hilo vaya al estado sleep durante x milisegundos.
   Cuando un hilo entra en estado de reposo it doesn’t release the lock.

3. wait() permite que thread libere el bloqueo y goes to suspended state.
   Este hilo estará activo cuando un método notify() o notifAll() sea pidió el mismo objeto.

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

• llamando interrupt() durante sleep() siempre lanza una excepción (por ejemplo, InterrumpedException ), mientras que
• llamar notify() durante wait() no.

Generar una excepción cuando no es necesaria es ineficiente. Si tienes hilos que se comunican entre sí a un ritmo alto, entonces generaría muchas excepciones si fueras interrumpir llamadas todo el tiempo, lo que es un desperdicio total de CPU.

Estás en lo correcto - Sleep() hace que ese subproceso se "duerma" y la CPU se apagará y procesará otros subprocesos (también conocidos como cambio de contexto) donde creo que Wait mantiene la CPU procesando el subproceso actual.

Tenemos ambos porque aunque puede parecer sensato dejar que otras personas usen la CPU mientras no la estás usando, en realidad hay una sobrecarga para el cambio de contexto-dependiendo de cuánto tiempo dure la suspensión, puede ser más costoso en ciclos de CPU cambiar hilos que es simplemente tener su hilo no hacer nada por unos pocos ms.

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

También - en general no es posible controlar el cambio de contexto - durante la Espera, el sistema operativo puede (y lo hará durante esperas más largas) elegir procesar otros subprocesos.

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.

Hilo.sleep (n) puede ser interrumpido, pero Objeto.wait () debe ser notificado. Es posible especificar el tiempo máximo de espera: Object.wait(5000) por lo que sería posible usar wait para, er, sleep pero luego tienes que preocuparte por los bloqueos.

Ninguno de los métodos utiliza la cpu mientras duerme/espera.

Los métodos se implementan usando código nativo, usando construcciones similares pero no en el mismo manera.

Compruébelo usted mismo: ¿Está disponible el código fuente de los métodos nativos? El archivo /src/share/vm/prims/jvm.cpp es el punto de partida...

Aquí wait() estará en el estado de espera hasta que notifique por otro Hilo pero donde as sleep() estará teniendo algún tiempo..después de esto se transferirá automáticamente al estado listo...

¿Diferencias entre Wait () y sleep ()?

Hilo.dormir() Una vez completado su trabajo, solo su liberación de la cerradura a todos. hasta que nunca suelte la cerradura a nadie.

  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.

Objeto.Esperen() Cuando su va a la etapa de espera, su será liberar la clave y su espera para algunos de los segundos basados en el parámetro.

Por Ejemplo:

Usted es tomar el café en su mano derecha, usted puede tomar otro cualquiera de la misma mano, cuando su poner entonces solo tome otro objeto del mismo tipo aquí. también. esto es dormir.() usted duerme el tiempo que usted no hizo ningún trabajo, usted está haciendo solamente dormir.. lo mismo aquí también.

Wait(). cuando usted es puesto abajo y tomar otro medio mientras que usted está esperando , eso es esperar

Usted es reproducir película o cualquier cosa en el suyo sistema igual que el jugador no se puede reproducir más de uno a la vez derecha, eso es su aquí, cuando se cierra y elegir otra cualquiera película o canción significa mientras se llama espera

wait libera el bloqueo y sleep no lo hace. Un hilo en estado de espera es elegible para despertarse tan pronto como se llame notify o notifyAll. Pero en el caso de sleep el hilo mantiene el bloqueo y solo será elegible una vez que el tiempo de sueño haya terminado.

sleep() el método hace que el subproceso actual se mueva del estado de ejecución al estado de bloque durante un tiempo especificado. Si el subproceso actual tiene el bloqueo de cualquier objeto, lo mantiene retenido, lo que significa que otros subprocesos no pueden ejecutar ningún método sincronizado en ese objeto de clase.

wait() el método hace que el subproceso actual entre en estado de bloque durante un tiempo especificado o hasta que notify, pero en este caso el subproceso libera el bloqueo del objeto (lo que significa que otros subprocesos pueden ejecutarse cualquier método sincronizado del objeto que llama.

En mi opinión, la principal diferencia entre ambos mecanismos es que sleep/interrupt es la forma más básica de manejar subprocesos, mientras que wait/notify es una abstracción destinada a facilitar la intercomunicación de subprocesos. Esto significa que dormir/interrumpir puede hacer cualquier cosa, pero que esta tarea específica es más difícil de hacer.

¿Por qué es más adecuado esperar/notificar? Estas son algunas consideraciones personales:

1. Refuerza la centralización. Permite coordinar la comunicación entre un grupo de hilos con un único objeto compartido. Esto simplifica mucho el trabajo.

2. Impone la sincronización. Porque hace que el programador envuelva la llamada a wait/notify en un bloque sincronizado.

3. Es independiente del origen y número del hilo. Con este enfoque puede agregar más subprocesos arbitrariamente sin editar los otros subprocesos o mantener un seguimiento de los existentes. Si ha utilizado sleep / interrupt, primero tendría que mantener las referencias a los hilos para dormir, y luego interrumpirlos uno por uno, a mano.

Un ejemplo de la vida real que es bueno para explicar esto es un restaurante clásico y el método que utiliza el personal para comunicarse entre ellos: Los camareros dejan las solicitudes de los clientes en un lugar central (una tabla de corcho, una mesa, etc.).), suena una campana, y los trabajadores de la cocina vienen a tomar tales peticiones. Una vez que hay cualquier curso listo, el personal de cocina toca el timbre de nuevo para que los camareros estén al tanto y los lleven a los clientes.

Ejemplo sobre sleep no libera lock y wait sí

Aquí hay dos clases:

1. Main : Contiene el método principal y dos hilos.

2. Singleton : Esta es la clase singleton con dos métodos estáticos getInstance() y 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;

 }
}

Ahora ejecute este ejemplo obtendrá la siguiente salida:

_instance :null
Both singleton are same

Aquí las instancias Singleton creadas por ThreadA y ThreadB son iguales. Significa que ThreadB está esperando afuera hasta que ThreadA libere su cerradura.

Ahora cambia el Singleton.java comentando el hilo.sleep (500); método y Singleton sin comentar.clase.espere(500);. Aquí por Singleton.clase.wait (500); el método ThreadA liberará todos los bloqueos de adquisición y se moverá al estado "No ejecutable", ThreadB obtendrá el cambio para entrar en el bloque sincronizado.

Ahora corre de nuevo:

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

Aquí las instancias Singleton creadas por ThreadA y ThreadB NO son lo mismo debido a ThreadB consiguió el cambio para entrar en bloque sincronizado y después de 500 milisegundos ThreadA comenzó desde su última posición y creó un objeto Singleton más.

Debe ser llamado desde el bloque sincronizado : wait() el método siempre se llama desde un bloque sincronizado, es decir, el método wait() necesita bloquear object monitor antes del objeto en el que se llama. Pero el método sleep() se puede llamar desde un bloque sincronizado externo, es decir, el método sleep() no necesita ningún monitor de objetos.

IllegalMonitorStateException: si se llama al método wait() sin adquirir object lock, IllegalMonitorStateException se lanza en tiempo de ejecución, pero sleep() el método nunca lanza tal salvedad.

Pertenece a qué clase : wait() method belongs to java.lang.Object class but sleep() method belongs to java.lang.Thread class.

Invocado en objeto o hilo : wait() el método es llamado en objetos pero sleep() el método es llamado en hilos no en objetos.

Estado del subproceso: cuando se llama al método wait() en el objeto, el subproceso que mantiene el monitor del objeto pasa del estado de ejecución al estado de espera y puede volver al estado ejecutable solo cuando el método notify() o notifyAll() llamado a ese objeto. Y más tarde, el programador de subprocesos programa ese subproceso para pasar de ejecutable a estado en ejecución. cuando se llama a sleep() en thread, pasa del estado de ejecución al estado de espera y puede volver al estado ejecutable cuando se agota el tiempo de reposo.

Cuando se llama desde un bloque sincronizado: cuando se llama al método wait() thread sale del bloqueo del objeto. Pero el método sleep() cuando se llama desde el bloque sincronizado o el hilo del método no deja el bloqueo del objeto.

Para Más Referencia

De la página de documentación de oracle en wait () método de Object:

public final void wait()

1. Hace que el subproceso actual espere hasta que otro subproceso invoque el método notify() o el método notifyAll() para este objeto. En otras palabras, este método se comporta exactamente como si simplemente realizara la llamada wait(0).
2. El subproceso actual debe poseer el monitor de este objeto. El subproceso libera la propiedad de este monitor y espera hasta que otro subproceso notifique los subprocesos que esperan en el monitor de este objeto para despertar
3. las interrupciones y espurias wakeups son posibles
4. Este método solo debe ser llamado por un hilo que es el propietario del monitor de este objeto

Este método arroja

1. IllegalMonitorStateException - si el subproceso actual no es el propietario del monitor del objeto.

2. InterruptedException - si algún subproceso interrumpió el subproceso actual antes o mientras el subproceso actual estaba esperando una notificación. El estado interrumpido de la el hilo actual se borra cuando se lanza esta excepción.

De la página de documentación de oracle en sleep () método de Thread clase:

public static void sleep(long millis)

1. Hace que el subproceso actualmente en ejecución se suspenda (cese temporalmente la ejecución) durante el número especificado de milisegundos, sujeto a la precisión y precisión de los temporizadores y planificadores del sistema.
2. El subproceso no pierde la propiedad de ningún monitor.

Este método tiros:

1. IllegalArgumentException - si el valor de millis es negativo

2. InterruptedException - si algún hilo ha interrumpido el hilo actual. El estado de interrupción del hilo actual se borra cuando se lanza esta excepción.

Otra diferencia clave:

wait() es un método no estático (método de instancia) a diferencia del método estático sleep() (método de clase).

• El método wait(1000) hace que el subproceso actual a dormir hasta un segundo.
  • Un hilo podía dormir menos de 1 segundo si se recibe el notify() o notifyAll() llamada de método.
• La llamada a sleep(1000) hace que el hilo actual duerma durante exactamente 1 segundo.
  • También el hilo de dormir no mantiene bloqueado ningún recurso. Pero esperando hilo hacer.

wait() se da dentro de un método sincronizado mientras que sleep() se da dentro de un método no sincronizado porque el método wait() libera el bloqueo en el objeto, pero sleep() o yield() libera el lock().