Quelle est la différence entre a wait()
et sleep()
dans Threads?
Est-ce que je comprends qu'un wait()
thread -ing est toujours en mode de fonctionnement et utilise des cycles CPU mais qu'un sleep()
-ing ne consomme aucun cycle CPU correct?
Pourquoi avons-nous les deux wait()
et sleep()
: comment leur mise en œuvre varie-t-elle à un niveau inférieur?
Réponses:
Un
wait
peut être "réveillé" par un autre thread appelantnotify
le moniteur qui est attendu alors qu'unsleep
ne peut pas. De plus, unwait
(etnotify
) doit se produire dans un blocsynchronized
sur l'objet moniteur alors quesleep
ne:À ce stade, le thread en cours d'exécution attend et libère le moniteur . Un autre fil peut faire
(sur le même
mon
objet) et le premier thread (en supposant que c'est le seul thread en attente sur le moniteur) se réveillera.Vous pouvez également appeler
notifyAll
si plusieurs threads attendent sur le moniteur - cela les réveillera tous . Cependant, un seul des threads pourra saisir le moniteur (rappelez-vous que lewait
est dans unsynchronized
bloc) et continuer - les autres seront alors bloqués jusqu'à ce qu'ils puissent acquérir le verrouillage du moniteur.Un autre point est que vous appelez
wait
surObject
lui - même (vous attendez sur le moniteur d'un objet) alors que vous appelezsleep
leThread
.Pourtant , un autre point est que vous pouvez obtenir des redémarrages parasites de
wait
(le fil qui est en attente reprend sans raison apparente). Vous devriez toujourswait
pendant la rotation à certaines conditions comme suit:la source
wait
/notify
sont généralement utilisés pour attendre qu'un autre thread accomplisse une tâche, ou pour attendre qu'une certaine condition soit satisfaite.Une différence clé non encore mentionnée est que pendant le sommeil, un thread ne libère pas les verrous qu'il détient, tandis que l'attente libère le verrou sur l'objet
wait()
appelé.la source
sleep
détient les verrous java , mais ce n'est pas le cas. Pour avoir une comparaison juste, nous comparerionssynchronized(OUTER_LOCK){ Thread.sleep(1000); }
avecsynchronized(OUTER_LOCK){ synchronized(LOCK){LOCK.wait();} }
et nous pouvons voir que les deux instructions ne libèrent pas leOUTER_LOCK
. S'il y a une différence, on peut dire quesleep
ne pas explicitement utiliser Java verrous, mais la question se pose sur devis « comment leur mise en œuvre varient à un niveau inférieur? » fin de citation.wait()
est associé à la condition du verrou le plus interne à partir duquel il est appelé, dans votre exemple de code,wait()
ne peut que se libérerLOCK
et nonOUTER_LOCK
. C'est ainsi que le moniteur Java est conçu de toute façon. Une comparaison équitable seraitsynchronized(OUTER_LOCK){ synchronized(LOCK) { Thread.sleep(1000); } }
etsynchronized(OUTER_LOCK){ synchronized(LOCK) { LOCK.wait(); } }
. Dans ce cassleep()
, les deux verrous seront maintenus pendant qu'ilswait()
seront libérés,LOCK
mais toujoursOUTER_LOCK
J'ai trouvé ce post utile. Il met la différence entre
Thread.sleep()
,Thread.yield()
etObject.wait()
en termes humains. Citer:la source
sleep(n)
signifie implicitement que le thread en cours d'exécution abandonne volontairement le moniteur du verrou, ce qui n'est pas vrai . Citation du javadoc de Thread : "Le thread ne perd la propriété d'aucun moniteur."sleep
n'a pas de comportement spécial concernant le moniteur que tout autre appel de méthode Java, c'est-à-dire qu'il ne les interagit pas ou ne les modifie en aucune façon. Si vous voulez dire quelque chose à propos des moniteurs, vous devez spécifier quewait
, en plus des éléments mentionnés ci-dessus, vous abandonnerez temporairement le verrou sur l'objet auquel il est appelé.wait(n)
pour comparer avecsleep(n)
. Il n'y a aucun sens à comparer en utilisant celui sans argument.Il y a beaucoup de réponses ici mais je n'ai trouvé la distinction sémantique mentionnée sur aucune.
Il ne s'agit pas du fil lui-même; les deux méthodes sont nécessaires car elles prennent en charge des cas d'utilisation très différents.
sleep()
envoie le thread en veille comme il l'était auparavant, il ne fait que compresser le contexte et arrête de s'exécuter pendant une durée prédéfinie. Donc, pour le réveiller avant l'heure prévue, vous devez connaître la référence Thread. Ce n'est pas une situation courante dans un environnement multithread. Il est principalement utilisé pour la synchronisation de l'heure (par exemple, réveil en 3,5 secondes exactement) et / ou l'équité codée en dur (il suffit de dormir pendant un certain temps et de laisser les autres threads fonctionner).wait()
, au contraire, est un mécanisme de synchronisation de thread (ou de message) qui vous permet de notifier un Thread dont vous n'avez aucune référence stockée (ni attention). Vous pouvez le considérer comme un modèle de publication-abonnement (wait
== abonnement etnotify()
== publication). Fondamentalement, en utilisant notify (), vous envoyez un message (qui pourrait même ne pas être reçu du tout et normalement vous ne vous en souciez pas).Pour résumer, vous utilisez normalement la
sleep()
synchronisation temporelle et la synchronisationwait()
multi-thread.Ils pouvaient être implémentés de la même manière dans le système d'exploitation sous-jacent, ou pas du tout (car les versions précédentes de Java n'avaient pas de véritable multithreading; probablement certaines petites machines virtuelles ne le font pas non plus). N'oubliez pas que Java s'exécute sur une VM, donc votre code sera transformé en quelque chose de différent en fonction de la VM / OS / HW sur laquelle il s'exécute.
la source
Ici, j'ai énuméré quelques différences importantes entre les méthodes
wait()
etsleep()
.PS: Cliquez également sur les liens pour voir le code de la bibliothèque (fonctionnement interne, il suffit de jouer un peu pour une meilleure compréhension).
attendre()
wait()
libère le verrou.wait()
est la méthode deObject
classe.wait()
est la méthode non statique -public final void wait() throws InterruptedException { //...}
wait()
doivent être notifiés parnotify()
ounotifyAll()
méthodes.wait()
La méthode doit être appelée à partir d'une boucle afin de traiter les fausses alarmes.wait()
La méthode doit être appelée à partir d'un contexte synchronisé (c'est-à-dire une méthode synchronisée ou un bloc), sinon elle lanceraIllegalMonitorStateException
dormir()
sleep()
ne libère pas le verrou.sleep()
est la méthode dejava.lang.Thread
classe.sleep()
est la méthode statique -public static void sleep(long millis, int nanos) throws InterruptedException { //... }
sleep()
est terminée.sleep()
mieux ne pas appeler depuis la boucle (c'est -à- dire voir le code ci-dessous ).sleep()
peut être appelé de n'importe où. il n'y a pas d'exigence spécifique.Réf: Différence entre attente et sommeil
Extrait de code pour appeler la méthode wait et sleep
la source
Thread.sleep()
est utilisé pour rendre le temps processeur disponible pour les autres threads. la période de sommeil peut être interrompue par des interruptions (c'est-à-dire par JVM). Lisez ce stackoverflow.com/questions/4264355/…notify()
ounotifyAll()
sontObject
des méthodes de classe. par conséquent, ils sont disponibles obj de toutes les classes (c'est-à-dire ici avecThread
classe aussi). voir le code grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/…Il y a quelques notes clés de différence que je conclus après avoir travaillé sur l'attente et le sommeil, jetez d'abord un coup d'œil sur l'échantillon en utilisant wait () et sleep ():
Exemple 1 : en utilisant wait () et sleep ():
Laissez la clarté quelques notes clés:
Corrigez-moi si j'ai tort, s'il-vous plait.
la source
Différence entre wait () et sleep ()
La différence fondamentale est que
wait()
provientObject
etsleep()
est une méthode statiqueThread
.La principale différence est que
wait()
lesleep()
déverrouillage ne libère aucun verrou en attendant.wait()
est utilisé pour la communication inter-thread tandis quesleep()
est utilisé pour introduire une pause sur l'exécution, en général.wait()
devrait être appelé depuis synchroniser à l'intérieur ou bien nous obtenons unIllegalMonitorStateException
, tandis quesleep()
peut être appelé n'importe où.wait()
, vous devez appelernotify()
ounotifyAll()
. Quantsleep(),
au thread, il démarre après un intervalle de temps spécifié.Similitudes
la source
C'est une question très simple, car ces deux méthodes ont une utilisation totalement différente.
La principale différence est d'attendre pour libérer le verrou ou le moniteur pendant que le sommeil ne libère aucun verrou ou moniteur pendant l'attente. Wait est utilisé pour la communication entre les threads tandis que sleep est utilisé pour introduire une pause lors de l'exécution.
Ce n'était qu'une explication claire et basique, si vous voulez plus que cela, continuez à lire.
En cas de
wait()
thread de méthode en attente et il ne reviendra pas automatiquement jusqu'à ce que nous appelions lanotify()
méthode (ounotifyAll()
si vous avez plus d'un thread en attente et que vous souhaitez réveiller tous ces threads). Et vous avez besoin synchronisé ou verrouillage de l' objet ou le verrouillage de classe pour accéder auwait()
ounotify()
ounotifyAll()
méthodes. Et encore une chose, lawait()
méthode est utilisée pour la communication entre les threads, car si un thread passe en attente, vous aurez besoin d'un autre thread pour le réveiller.Mais dans ce cas,
sleep()
c'est une méthode qui est utilisée pour maintenir le processus pendant quelques secondes ou le temps que vous voulez. Parce que vous n'avez pas besoin de provoquer unenotify()
ounotifyAll()
méthode pour obtenir ce retour de fil. Ou vous n'avez besoin d'aucun autre fil pour rappeler ce fil. Comme si vous voulez que quelque chose se produise après quelques secondes, comme dans un jeu après le tour de l'utilisateur, vous voulez que l'utilisateur attende que l'ordinateur joue, alors vous pouvez mentionner lasleep()
méthode.Et une autre différence importante qui est souvent demandée lors des entretiens:
sleep()
appartient à laThread
classe etwait()
appartient à laObject
classe.Ce sont toutes les différences entre
sleep()
etwait()
.Et il existe une similitude entre les deux méthodes: elles sont toutes deux vérifiées, vous devez donc essayer catch ou throw pour accéder à ces méthodes.
J'espère que cela t'aidera.
la source
source: http://www.jguru.com/faq/view.jsp?EID=47127
la source
Attendre et dormir sont deux choses différentes:
sleep()
le thread cesse de fonctionner pendant la durée spécifiée.wait()
le thread cesse de fonctionner jusqu'à ce que l'objet attendu soit notifié, généralement par d'autres threads.la source
sleep
, si vous voulez qu'il s'arrête jusqu'à ce que certaines entrées proviennent de l'autre que vous utilisezwait
/notify
.interrupt
est conçu comme un moyen de signaler à un thread qu'il doit arrêter de faire ce qu'il fait et se terminer. Il est géré parsleep
,wait
mais bloque également les fonctions d'E / S (et vous pouvez implémenter des fonctions avec le même comportement en appelant la méthodeThread.interrupted()
). En ce qui concerne les performances, les fonctions sont généralement optimisées pour l'objectif pour lequel elles ont été conçues.sleep
est une méthode deThread
,wait
est une méthode deObject
,wait/notify
est donc une technique de synchronisation des données partagées en Java (en utilisant le moniteur ), maissleep
est une méthode simple de thread pour se mettre en pause.la source
sleep () est une méthode qui est utilisée pour maintenir le processus pendant quelques secondes ou le temps que vous vouliez mais en cas de thread de méthode wait () passe en état d'attente et il ne reviendra pas automatiquement jusqu'à ce que nous appelons le notify () ou notifyAll ().
La principale différence est que wait () libère le verrou ou le moniteur pendant que sleep () ne libère aucun verrou ou moniteur pendant l'attente. Wait est utilisé pour la communication entre les threads tandis que sleep est utilisé pour introduire une pause lors de l'exécution, en général.
Thread.sleep () envoie le thread actuel à l'état "Not Runnable" pendant un certain temps. Le thread conserve les moniteurs qu'il a acquis - c'est-à-dire que si le thread est actuellement dans un bloc ou une méthode synchronisée, aucun autre thread ne peut entrer dans ce bloc ou cette méthode. Si un autre thread appelle t.interrupt (), il réveillera le thread en veille. Notez que sleep est une méthode statique, ce qui signifie qu'elle affecte toujours le thread actuel (celui qui exécute la méthode sleep). Une erreur courante consiste à appeler t.sleep () où t est un thread différent; même alors, c'est le thread actuel qui dormira, pas le thread t.
object.wait () envoie le thread actuel dans l'état "Not Runnable", comme sleep (), mais avec une torsion. L'attente est appelée sur un objet, pas sur un thread; nous appelons cet objet «l'objet verrouillé». Avant d'appeler lock.wait (), le thread actuel doit se synchroniser sur l'objet lock; wait () libère alors ce verrou et ajoute le fil à la «liste d'attente» associée au verrou. Plus tard, un autre thread peut se synchroniser sur le même objet de verrouillage et appeler lock.notify (). Cela réveille le fil d'origine en attente. Fondamentalement, wait () / notify () est comme sleep () / interrupt (), seul le thread actif n'a pas besoin d'un pointeur direct vers le thread endormi, mais uniquement vers l'objet de verrouillage partagé.
Classons tous les points ci-dessus:
Call on:
Synchronized:
Hold lock:
Wake-up condition:
Usage:
Réf: diff
sleep
etwait
la source
En termes simples, wait is wait Jusqu'à ce qu'un autre thread vous invoque alors que sleep est "don't execute next statement" pendant une période de temps spécifiée.
De plus, sleep est une méthode statique dans la classe Thread et il fonctionne sur le thread, tandis que wait () est dans la classe Object et appelé sur un objet.
Un autre point, lorsque vous appelez wait sur un objet, le thread impliqué synchronise l'objet, puis attend. :)
la source
wait
et lessleep
méthodes sont très différentes:sleep
n'a aucun moyen de "se réveiller",wait
a un moyen de "se réveiller" pendant la période d'attente, par un autre thread appelantnotify
ounotifyAll
.À bien y penser, les noms prêtent à confusion à cet égard;
sleep
est cependant un nom standard etwait
ressemble àWaitForSingleObject
ouWaitForMultipleObjects
dans l'API Win.la source
De cet article: http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/
Méthode wait ().
1) Le thread qui appelle la méthode wait () libère le verrou qu'il détient.
2) Le thread retrouve le verrou après que d'autres threads ont appelé les méthodes notify () ou notifyAll () sur le même verrou.
3) la méthode wait () doit être appelée dans le bloc synchronisé.
4) La méthode wait () est toujours appelée sur les objets.
5) Les threads en attente peuvent être réveillés par d'autres threads en appelant les méthodes notify () ou notifyAll ().
6) Pour appeler la méthode wait (), le thread doit avoir un verrou d'objet.
sleep (), méthode
1) Le thread qui appelle la méthode sleep () ne libère pas le verrou qu'il détient.
2) la méthode sleep () peut être appelée à l'intérieur ou à l'extérieur du bloc synchronisé.
3) La méthode sleep () est toujours appelée sur les threads.
4) Les fils dormants ne peuvent pas être réveillés par d'autres fils. Si c'est le cas, le thread lèvera InterruptedException.
5) Pour appeler la méthode sleep (), le thread n'a pas besoin d'avoir le verrouillage d'objet.
la source
Ici, wait () sera dans l'état d'attente jusqu'à ce qu'il le notifie par un autre thread, mais où sleep () aura un certain temps..après cela, il passera automatiquement à l'état Ready ...
la source
wait()
est une méthode deObject
classe.sleep()
est une méthode deThread
classe.sleep()
permet au thread de passer à l'sleep
état pendant x millisecondes.Lorsqu'un fil se met en veille
it doesn’t release the lock
.wait()
permet au fil de libérer le verrou etgoes to suspended state
.Ce thread sera actif lorsqu'une méthode
notify()
ornotifAll()
sera appelée pour le même objet.la source
Une grande différence potentielle entre sommeil / interruption et attente / notification est que
interrupt()
pendantsleep()
lève toujours une exception (par exemple, InterruptedException ), tandis quenotify()
pendantwait()
ne fonctionne pas.Générer une exception lorsqu'elle n'est pas nécessaire est inefficace. Si vous avez des threads qui communiquent entre eux à un taux élevé, cela générerait de nombreuses exceptions si vous appeliez constamment interruption, ce qui est un gaspillage total de CPU.
la source
Vous avez raison - Sleep () fait que ce thread se "met en veille" et le CPU s'éteint et traite les autres threads (autrement connu sous le nom de changement de contexte) alors que je pense que Wait attend que le CPU traite le thread actuel.
Nous avons les deux parce que même si cela peut sembler judicieux de laisser d'autres personnes utiliser le processeur pendant que vous ne l'utilisez pas, en réalité, il y a un surcoût pour le changement de contexte - selon la durée du sommeil, il peut être plus cher dans les cycles du processeur pour changer de threads que pour simplement avoir votre thread ne rien faire pendant quelques ms.
Notez également que le sommeil force un changement de contexte.
De plus - en général, il n'est pas possible de contrôler le changement de contexte - pendant l'attente, le système d'exploitation peut (et va attendre plus longtemps) choisir de traiter d'autres threads.
la source
interrupt
. L'heure de fin estn
enwait(n)
. ¶¶ Cela fait maintenant 8 ans et personne n'a encore la réponse!Les méthodes sont utilisées pour différentes choses.
Thread.sleep (n) peut être interrompu, mais Object.wait () doit être notifié. Il est possible de spécifier le temps maximum à attendre:
Object.wait(5000)
il serait donc possible d'utiliserwait
pour, euh,sleep
mais alors vous devez vous soucier des verrous.Aucune des méthodes n'utilise le processeur pendant le sommeil / l'attente.
Les méthodes sont implémentées en utilisant du code natif, en utilisant des constructions similaires mais pas de la même manière.
Cherchez par vous-même: le code source des méthodes natives est-il disponible? Le fichier
/src/share/vm/prims/jvm.cpp
est le point de départ ...la source
Thread.sleep(big_num)
doit être interrompu.Object.wait(small_num)
peut être notifié.Attendre () et dormir () Différences?
Thread.sleep () Une fois son travail terminé, il ne reste plus qu'à libérer le verrou à tout le monde. jusqu'à ce que cela ne libère jamais le verrou à personne.
Object.wait () Lorsqu'il passera à l'étape d'attente, il relâchera la clé et attendra quelques secondes en fonction du paramètre.
Par exemple:
vous prenez le café dans la main droite, vous pouvez prendre un autre personne de la même main, quand allez-vous déposer puis ne prendre qu'un autre objet du même type ici. aussi. c'est le sommeil () vous dormez, vous n'avez pas travaillé, vous ne faites que dormir .. même ici aussi.
attendre(). quand vous êtes abattu et prenez un autre moyen pendant que vous attendez, c'est attendre
vous jouez un film ou quoi que ce soit dans votre système de la même manière que le joueur, vous ne pouvez pas en jouer plus d'un à la fois, c'est ici, lorsque vous fermez et choisissez un autre film ou chanson de quelqu'un pendant que s'appelle attendre
la source
wait
libère le verrou etsleep
ne le fait pas. Un fil dans l' état d' attente est admissible à se réveiller dèsnotify
ounotifyAll
est appelé. Mais dans le cas oùsleep
le fil garde le verrou et il ne sera éligible qu'une fois le temps de sommeil terminé.la source
InterruptedException
est lancé, comme il est dit dans le Javadoc.sleep()
fait en sorte que le thread en cours passe de l'état d'exécution à l'état de blocage pendant une durée spécifiée. Si le thread actuel a le verrou de n'importe quel objet, il continue à le maintenir, ce qui signifie que les autres threads ne peuvent exécuter aucune méthode synchronisée dans cet objet de classe.wait()
La méthode fait que le thread actuel entre dans l'état de bloc pendant une durée spécifiée ou jusqu'à notification, mais dans ce cas, le thread libère le verrou de l'objet (ce qui signifie que d'autres threads peuvent exécuter toutes les méthodes synchronisées de l'objet appelant.la source
À mon avis, la principale différence entre les deux mécanismes est que le mode veille / interruption est le moyen le plus élémentaire de gérer les threads, tandis que l' attente / notification est une abstraction visant à faciliter l'intercommunication des threads.Cela signifie que le sommeil / interruption peut tout faire, mais que cette tâche spécifique est plus difficile à faire.
Pourquoi attendre / notifier est-il plus approprié? Voici quelques considérations personnelles:
Il impose la centralisation. Il permet de coordonner la communication entre un groupe de threads avec un seul objet partagé. Cela simplifie beaucoup le travail.
Il applique la synchronisation. Parce que le programmeur encapsule l'appel pour attendre / notifier dans un bloc synchronisé.
Il est indépendant de l'origine et du numéro du fil. Avec cette approche, vous pouvez ajouter plus de fils arbitrairement sans modifier les autres fils ou garder une trace de ceux existants. Si vous avez utilisé sleep / interruption, vous devez d'abord conserver les références aux threads en veille, puis les interrompre une par une, à la main.
Un exemple de la vie réelle qui est bon d'expliquer c'est un restaurant classique et la méthode que le personnel utilise pour communiquer entre eux: Les serveurs laissent les demandes des clients dans un endroit central (une planche de liège, une table, etc.), sonner la cloche, et les ouvriers de la cuisine viennent prendre ces demandes. Une fois qu'un cours est prêt, le personnel de cuisine sonne à nouveau pour que les serveurs soient au courant et les amènent aux clients.
la source
Un exemple de sommeil ne libère pas le verrou et
Ici, il y a deux classes:
Singleton : il s'agit de la classe singleton avec deux méthodes statiques getInstance () et getInstance (boolean isWait).
et
Maintenant, exécutez cet exemple, vous obtiendrez ci-dessous la sortie:
Ici, les instances Singleton créées par threadA et threadB sont identiques. Cela signifie que le threadB attend à l'extérieur jusqu'à ce que le threadA libère son verrou.
Maintenant, changez Singleton.java en commentant Thread.sleep (500); méthode et décommentation Singleton.class.wait (500); . Ici à cause de Singleton.class.wait (500); La méthode threadA libérera tous les verrous d'acquisition et passera à l'état «Non exécutable», threadB obtiendra la modification à entrer dans le bloc synchronisé.
Maintenant, exécutez à nouveau:
Ici, les instances Singleton créées par threadA et threadB ne sont PAS les mêmes car threadB a obtenu une modification pour entrer dans le bloc synchronisé et après 500 millisecondes, threadA a démarré à partir de sa dernière position et a créé un autre objet Singleton.
la source
Doit être appelée à partir du bloc synchronisé: la
wait()
méthode est toujours appelée à partir du bloc synchronisé, c'est-à-dire que lawait()
méthode doit verrouiller le moniteur d'objet avant l'objet sur lequel elle est appelée. Mais lasleep()
méthode peut être appelée depuis un bloc synchronisé externe, c'est-à-dire qu'ellesleep()
n'a pas besoin de moniteur d'objet.IllegalMonitorStateException: si la
wait()
méthode est appelée sans acquérir le verrou d'objet, elleIllegalMonitorStateException
est levée lors de l'exécution, maissleep()
méthode ne lève jamais une telle exception.Appartient à quelle classe: la
wait()
méthode appartient à lajava.lang.Object
classe mais lasleep()
méthode appartient à lajava.lang.Thread
classe.Appelé sur un objet ou un thread: la
wait()
méthode est appelée sur les objets mais lasleep()
méthode est appelée sur les threads et non sur les objets.État du thread: lorsque la
wait()
méthode est appelée sur l'objet, le thread qui contenait le moniteur de l'objet passe de l'état d'exécution à l'état d'attente et ne peut revenir à l'état d'exécution que lorsque la méthodenotify()
ounotifyAll()
est appelée sur cet objet. Et plus tard, le planificateur de threads planifie ce thread de passer de exécutable à l'état en cours d'exécution. quandsleep()
est appelé sur le thread, il passe de l'état d'exécution à l'état d'attente et peut revenir à l'état d'exécution lorsque le temps de veille est écoulé.En cas d'appel depuis un bloc synchronisé: lorsque la
wait()
méthode est appelée, le thread quitte le verrou de l'objet. Mais lasleep()
méthode lorsqu'elle est appelée à partir d'un bloc synchronisé ou d'un thread de méthode ne laisse pas le verrou d'objet.Pour plus de référence
la source
Depuis la page de documentation d'Oracle sur la méthode wait () de
Object
:notify()
méthode ou lanotifyAll()
méthode pour cet objet. En d'autres termes, cette méthode se comporte exactement comme si elle exécutait simplement l'appelwait(0)
.Cette méthode jette
IllegalMonitorStateException
- si le thread actuel n'est pas le propriétaire du moniteur de l'objet.InterruptedException
- si un thread a interrompu le thread actuel avant ou pendant que le thread actuel attendait une notification. Le statut interrompu du thread actuel est effacé lorsque cette exception est levée.Depuis la page de documentation d'Oracle sur la méthode de
Thread
classe sleep () :Cette méthode lance:
IllegalArgumentException
- si la valeur de millis est négativeInterruptedException
- si un thread a interrompu le thread actuel. Le statut interrompu du thread actuel est effacé lorsque cette exception est levée.Autre différence clé:
wait()
est une méthode non statique (méthode d'instance) contrairement à la méthode statiquesleep()
(méthode de classe).la source
wait()
est donné à l'intérieur d'une méthode synchronisée alors qu'ilsleep()
est donné à l'intérieur d'une méthode non synchronisée car lawait()
méthode libère le verrou sur l'objet maissleep()
ouyield()
libère lelock()
.la source
sleep()
peut être à l'intérieur d'unsynchronized
bloc ou d'une méthode. La réponse n'explique rien.wait(1000)
fait dormir le thread actuel jusqu'à une seconde .notify()
ornotifyAll()
.sleep(1000)
provoque la mise en veille du thread actuel pendant exactement 1 seconde .la source
sleep(1000)
ne garantit pas de dormir pendant exactement 1 seconde. Il peut être interrompu auparavant.En fait, tout cela est clairement décrit dans les documents Java (mais je ne l'ai réalisé qu'après avoir lu les réponses).
http://docs.oracle.com/javase/8/docs/api/index.html :
wait () - Le thread actuel doit posséder le moniteur de cet objet. Le thread libère la propriété de ce moniteur et attend qu'un autre thread notifie aux threads en attente sur le moniteur de cet objet de se réveiller via un appel à la méthode notify ou à la méthode notifyAll. Le thread attend ensuite jusqu'à ce qu'il puisse récupérer la propriété du moniteur et reprendre l'exécution.
sleep () - Fait dormir le thread en cours d'exécution (arrête temporairement l'exécution) pendant le nombre de millisecondes spécifié, sous réserve de la précision et de l'exactitude des temporisateurs et des planificateurs du système. Le thread ne perd la propriété d'aucun moniteur.
la source