thread - wait second in java




Diferencia entre esperar() y dormir() (20)

Diferencia entre esperar () y dormir ()

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

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

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

  • El wait() debe llamar desde adentro para sincronizar o, de lo contrario, obtendremos IllegalMonitorStateException mientras que sleep() puede llamar a cualquier lugar.

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

Similitudes que ayudan a entender.

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

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

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

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


dormir

  • Hace que el hilo en ejecución actual se duerma durante un tiempo específico.
  • Su precisión depende de los temporizadores y programadores 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 (), despertará el hilo de dormir.

Espere

  • Hace que el subproceso actual espere hasta que otro subproceso invoque el método notify () o el método notifyAll () para este objeto
  • Debe llamarse desde un contexto sincronizado, es decir, desde un bloque o método. Significa que antes de llamar al método wait (), el subproceso actual debe tener bloqueo en ese objeto.
  • Libera el bloqueo en el objeto en el que se llama y se agrega a la lista de espera, por lo que otro subproceso puede adquirir el bloqueo en el objeto.

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, solo juegue un poco para una mejor comprensión).

wait()

  1. wait() método wait() 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() métodos de notify() o notifyAll() .
  5. wait() método de wait() debe llamarse desde un bucle para tratar la falsa alarma.

  6. wait() método wait() debe llamarse desde un contexto sincronizado (es decir, un método o bloque sincronizado), de lo contrario lanzará la IllegalMonitorStateException

sleep()

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

Ref: Diferencia entre esperar y dormir.

Fragmento de código para el método de espera y suspensión de llamadas

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

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


De este post: http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

Espera () Método.

1) El hilo que llama al método wait () libera el bloqueo que mantiene.

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

3) El método de espera () debe llamarse dentro del bloque sincronizado.

4) El método de espera () siempre se llama en objetos.

5) Los subprocesos en espera pueden ser activados por otros subprocesos llamando a los métodos de notificación () o notificarAll ().

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

dormir () Método

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

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

3) El método sleep () siempre se llama en hilos.

4) Los hilos de dormir no pueden ser despertados por otros hilos. Si se hace así, el hilo lanzará InterruptedException.

5) Para llamar al método sleep (), el hilo no necesita tener bloqueo de objeto.


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 se notifica al objeto que está siendo esperado, generalmente por otros subprocesos.

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 la suspensión no libera ningún bloqueo o monitor mientras se espera. La espera se utiliza para la comunicación entre subprocesos, mientras que la suspensión se utiliza para introducir una 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() subproceso del método wait() pase al estado de espera, no volverá a aparecer automáticamente hasta que llamemos al método notifyAll() (o notifyAll() si tiene más de un subproceso en estado de espera y desea reactivar todos esos hilos). Y necesita sincronizar o bloquear objetos o objetos para acceder a los métodos wait() o notify() o notify() notifyAll() . Y una cosa más, el método wait() se utiliza para la comunicación entre subprocesos porque si un subproceso entra en estado de espera, necesitará otro subproceso para activar ese subproceso.

Pero en el caso de sleep() este es un método que se utiliza para mantener el proceso durante unos segundos o el tiempo deseado. Porque no es necesario provocar ningún método de notify() o notifyAll() para recuperar ese hilo. O no necesita ningún otro hilo para recuperar ese hilo. Si desea que algo suceda después de unos segundos, como en un juego después del turno del usuario, desea que el usuario espere hasta que la computadora juegue, puede mencionar el método sleep() .

Y otra diferencia 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 una declaración marcada, por lo que debe intentar atraparlos o lanzarlos para acceder a estos métodos.

Espero que esto ayude.


Hay muchas respuestas aquí 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 subproceso para dormir como estaba antes, solo empaqueta el contexto y deja de ejecutarse por un tiempo predefinido. Por lo tanto, para activarlo antes de la hora debida, debe conocer la referencia de Thread. Esta no es una situación común en un entorno de subprocesos múltiples. Se usa principalmente para la sincronización de tiempo (por ejemplo, despertar en exactamente 3,5 segundos) y / o imparcialidad codificada (solo dormir durante un tiempo y dejar que otros subprocesos 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 atención). Puedes considerarlo como un patrón de publicación-suscripción ( wait == suscribirte y notify() == publicar). Básicamente, al utilizar notificar (), está enviando un mensaje (que puede que incluso no se reciba y que normalmente no le importa).

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

Se podrían implementar de la misma manera en el sistema operativo subyacente, o no se implementaron (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.


He encontrado esta publicación útil. Pone la diferencia entre Thread.sleep() , Thread.yield() y Object.wait() en términos humanos. Citar:

Eventualmente, todo se reduce al programador del sistema operativo, que distribuye los intervalos de tiempo a los procesos y subprocesos.

sleep(n) dice "He terminado con mi intervalo de tiempo, y por favor no me des otro por al menos n milisegundos". El sistema operativo ni siquiera intenta programar el hilo de dormir hasta que haya transcurrido el tiempo solicitado.

yield() dice: "He terminado con mi intervalo de tiempo, pero todavía tengo trabajo por hacer". El sistema operativo es libre de darle de inmediato al hilo otro intervalo de tiempo, o de darle a otro hilo o procesar a la CPU el hilo de rendimiento que acaba de abandonar .

wait() dice: "He terminado con mi intervalo de tiempo. No me des otro intervalo de tiempo hasta que alguien llame a notificar (). ” Al igual que con el modo de sleep() , el sistema operativo ni siquiera intentará programar su tarea a menos que alguien llame a notify() (o se produzca uno de algunos otros escenarios de activación).

Los hilos también pierden el resto de su intervalo de tiempo cuando realizan el bloqueo de IO y en algunas otras circunstancias. Si un hilo funciona a lo largo de todo el intervalo de tiempo, el sistema operativo toma el control a la fuerza, aproximadamente, como si se hubiera llamado a yield() , para que otros procesos puedan ejecutarse.

Rara vez necesita el yield() , pero si tiene una aplicación de cómputo 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, no son '' t libre). Mide y prueba contra los objetivos que te interesan, como siempre.


Una diferencia clave que aún no se ha mencionado es que, mientras duerme, un subproceso no libera los bloqueos que mantiene, mientras espera libera el bloqueo en el objeto al que se llama a wait() .

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


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

Una gran diferencia potencial entre el modo de espera / interrupción y la espera / notificación es que

Generar una excepción cuando no es necesaria es ineficiente. Si tiene subprocesos que se comunican entre sí a una velocidad alta, entonces se generarían muchas excepciones si estuviera llamando a la interrupción todo el tiempo, lo que es una pérdida total de CPU.


Usted tiene razón: el modo Sleep () hace que el hilo se "duerma" y la CPU se apagará y procesará otros hilos (también conocidos como cambio de contexto) cuando creo que Wait mantiene a la CPU procesando el hilo actual.

Tenemos ambos porque, aunque puede parecer sensato permitir que otras personas utilicen la CPU mientras no la está utilizando, en la actualidad existe una sobrecarga para el cambio de contexto: dependiendo de cuánto tiempo dura la suspensión, puede ser más costoso en los ciclos de la CPU. para cambiar los hilos de lo que es simplemente hacer que tu hilo no haga nada durante unos pocos ms.

También tenga en cuenta que el sueño obliga a un cambio de contexto.

Además, en general, no es posible controlar el cambio de contexto; durante la Espera, el sistema operativo puede (y esperará por más tiempo) elegir procesar otros subprocesos.


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

Thread.sleep() envía el hilo actual al estado "No ejecutable" durante un período de tiempo determinado. 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 de dormir.

Tenga en cuenta que el modo de suspensión es un método estático, lo que significa que siempre afecta al subproceso 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 va a dormir, no el hilo t.

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

object.wait() envía el hilo actual al estado "No ejecutable" , como sleep() , pero con un giro. Se llama a la espera en un objeto, no un hilo; Llamamos a este objeto el "objeto de bloqueo". Antes de lock.wait() , el subproceso actual debe sincronizarse en el objeto de bloqueo; wait() libera este bloqueo y agrega el hilo a la "lista de espera" asociada con el bloqueo. Más tarde, otro hilo puede sincronizarse en el mismo objeto de bloqueo y llamar a lock.notify() . Esto despierta el hilo original, en espera. Básicamente, wait() / notify() es como sleep() / interrupt() , solo el hilo activo no necesita un puntero directo al hilo inactivo, sino solo al objeto de bloqueo compartido.


sleep()El método hace que el hilo actual pase del estado de ejecución al estado de bloqueo durante un tiempo específico. Si el subproceso actual tiene el bloqueo de cualquier objeto, entonces 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 pase al estado de bloqueo durante un tiempo específico o hasta que se notifique, pero en este caso el subproceso libera el bloqueo del objeto (lo que significa que otros subprocesos pueden ejecutar cualquier método sincronizado del objeto que llama).


sleep es un método de Thread , la 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 el monitor ), pero la sleep es un método simple de hebra para pausarse.



waitlibera el bloqueo y sleepno lo hace. Un hilo en el estado de espera es elegible para despertarse tan pronto como sea notifyo notifyAllque se llama. Pero en caso de que sleepel hilo mantenga el bloqueo, solo será elegible una vez que finalice el tiempo de suspensión.


sleep () es un método que se utiliza para mantener el proceso durante unos segundos o el tiempo que deseaba, pero en el caso de que el hilo del método wait () pase al estado de espera y no volverá automáticamente hasta que llamemos a notificar () o notificar a todos ().

La principal diferencia es que wait () libera el bloqueo o el monitor, mientras que sleep () no libera ningún bloqueo o monitor mientras se espera. La espera se utiliza para la comunicación entre subprocesos, mientras que la suspensión 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 período de tiempo determinado. El hilo conserva 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 de dormir. Tenga en cuenta que el modo de suspensión es un método estático, lo que significa que siempre afecta al subproceso 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 va a dormir, no el hilo t.

object.wait () envía el hilo actual al estado "No ejecutable", como sleep (), pero con un giro. Se llama a la espera en un objeto, no un hilo; llamamos a este objeto el "objeto de bloqueo". Antes de llamar a lock.wait (), el subproceso actual debe sincronizarse en el objeto de bloqueo; wait () libera este bloqueo y agrega el hilo a la "lista de espera" asociada con el bloqueo. Más tarde, otro hilo puede sincronizarse en el mismo objeto de bloqueo y llamar a lock.notify (). Esto despierta el hilo original, en espera. Básicamente, wait () / notify () es como sleep () / interrupt (), solo el hilo activo no necesita un puntero directo al hilo inactivo, 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:

  • esperar (): llamar a un objeto; el hilo actual debe sincronizarse en el objeto de bloqueo.
  • dormir (): llamar a un hilo; siempre ejecutando hilo actualmente.

Synchronized:

  • wait (): cuando varios subprocesos sincronizados acceden al mismo Objeto uno por uno.
  • dormir (): cuando hay varios subprocesos sincronizados, espera el reposo del subproceso.

Hold lock:

  • wait (): libera el bloqueo para que otros objetos tengan la oportunidad de ejecutarse.
  • dormir (): mantener el bloqueo por lo menos t veces si se especifica el tiempo de espera o si alguien interrumpe.

Wake-up condition:

  • espere (): hasta que notifique (), notifique a All () del objeto
  • dormir (): hasta que al menos el tiempo expire o llame a la interrupción ().

Usage:

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

Ref: diff sleep y wait


Aquí, wait () estará en el estado de espera hasta que lo notifique otro Hilo, pero mientras que sleep () tendrá algún tiempo ... después de que se transferirá automáticamente al estado Listo ...


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

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

Este método lanza

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

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

Desde la página de documentación de oracle sobre el método de clase sleep()Thread :

public static void sleep(long millis)
  1. Hace que el subproceso que se está ejecutando en ese momento esté en suspensión (cese temporalmente la ejecución) durante la cantidad especificada de milisegundos, sujeto a la precisión y exactitud de los programadores y temporizadores del sistema.
  2. El hilo no pierde la propiedad de ningún monitor.

Este método arroja:

  1. IllegalArgumentException - si el valor de millis es negativo

  2. InterruptedException- Si algún hilo ha interrumpido el hilo actual. El estado interrumpido 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).


En mi opinión, la principal diferencia entre ambos mecanismos es que el modo de espera / interrupción es la forma más básica de manejar los hilos, mientras que esperar / notificar es una abstracción destinada a facilitar la intercomunicación de los hilos. Esto significa que la suspensión / interrupción puede hacer cualquier cosa, pero que esta tarea específica es más difícil de hacer.

¿Por qué es más conveniente esperar / notificar? Aquí hay algunas consideraciones personales:

  1. Hace cumplir la centralización. Permite coordinar la comunicación entre un grupo de hilos con un solo objeto compartido. Esto simplifica mucho el trabajo.

  2. Hace cumplir la sincronización. Porque hace que el programador ajuste la llamada para esperar / notificar en un bloque sincronizado.

  3. Es independiente del origen y número del hilo. Con este enfoque, puede agregar más subprocesos de forma arbitraria sin editar los otros subprocesos o mantener un seguimiento de los existentes. Si utilizaste el modo de suspensión / interrupción, primero deberías mantener las referencias a los hilos de 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 (un tablero de corcho, una mesa, etc.). Toca el timbre, y los trabajadores de la cocina vienen a tomar esas peticiones. Una vez que haya preparado el curso, el personal de la cocina vuelve a tocar el timbre para que los camareros estén al tanto y se los lleven a los clientes.





java-threads