Différence entre wait() et sleep()
Quelle est la différence entre un wait()
et sleep()
dans les Threads?
Est ma compréhension que wait()
-ing Fil est toujours en mode de fonctionnement et les utilisations des cycles de CPU mais un sleep()
-ing ne consomme pas de cycles CPU correct?
Pourquoi nous avons les deux wait()
et sleep()
: comment leur mise en œuvre varient à un niveau inférieur?
- très bonne question. la sémantique de tous les deux sont faciles à confondre.
- Très joli questions, mais ils sont 2 dans un. Pourquoi avons-nous deux n'est pas la même que la façon dont ils peuvent (et ne sont pas!) mis en œuvre à un niveau inférieur. J'ai répondu à ça aussi.
- Supposons qu'un thread est dans un bloc synchronisé , et alors qu'il est dans la cpu de ce fil est pris et donné à un autre thread B. maintenant l'état dans lequel Un Thread va aller , les autres threads en attente sur ce bloc synchronisé maintenant venir à l'intérieur ?
- Voici un bon article qui décrit cela: qat.com/using-waitnotify-instead-thread-sleep-java
- son EXCATLY le contraire - sommeil "utilise" tous les de son PROCESSEUR disponible-cycles mais depuis le thread sera "en ATTENTE"de l'état-ces peut être donné si nécessaire - en fait, la plupart des systèmes d'exploitation automatiquement le rendement du cycle SI c'est possible, d'où votre fil ne créera aucune réelle de la charge CPU ... il va le faire sur les anciens systèmes d'exploitation, bien que. Objet.wait(), d'autre part n'utilise JAMAIS toutes cycles (tout en étant non notifiées) parce que c'est réalisé via le logiciel-les interruptions dans de nombreux cas - privé, transitoire & transparent serrures, mis en œuvre par la JVM. Fil de discussion.le sommeil est une mauvaise pratique.
- est une mauvaise pratique" s'il est utilisé au lieu de l'attendre. voir stackoverflow.com/questions/17826651/... Mais bon commentaire par.
Vous devez vous connecter pour publier un commentaire.
Un
wait
peut être "réveillé" par un autre thread appelantnotify
sur le moniteur qui est attendu sur attendu qu'unsommeil
ne peut pas. Aussi unwait
(etnotify
) qui doit se produire dans un blocsynchronized
sur le moniteur de l'objet alors quesleep
n':À ce point, le thread en cours d'exécution attend et libère le moniteur. Un autre thread 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) va se réveiller.Vous pouvez également appeler
notifyAll
si plus d'un thread est en attente sur le moniteur, cela va se réveiller toutes. Cependant, l'un des threads seront en mesure de saisir le moniteur (rappelez-vous que lawait
est dans unsynchronized
bloc) et portent sur les autres sera alors bloqué jusqu'à ce qu'ils puissent acquérir de l'écran de verrouillage.Un autre point est que vous appelez
wait
surObjet
lui-même (c'est à dire que vous attendez sur un objet de l'écran) alors que vous, vous appelezsleep
surThread
.Pourtant, un autre point est que vous pouvez obtenir fallacieux de réveils de
wait
(c'est à dire le fil qui est en attente reprend sans raison apparente). Vous devriez toujourswait
tandis que la filature sur une condition comme suit:wait
/notify
sont généralement utilisés pour attendre un autre thread pour accomplir une tâche, ou d'attendre jusqu'à ce qu'une certaine condition est remplie.while(runner.isAlive()){this.wait();}
gelé ici, comme leRunnable.run()
ne lenotify()
et quand il le fait, il est encore en vie; je me demande si il y a un moyen de savoir qui a notifié, de sorte que si la valeur est null ou pas celle attendue, qui boucle surwait()
seraient conservées, une idée?wait()
est semblable àpthread_cond_wait()
en C. Donc, l'attente du thread jusqu'à ce qu'un autre thread de l'en informer et il ne détient pas l'objet de champs.lock.notify()
que aussi être dans un bloc synchronisé?notify
. Avez-vous essayé en omettant le bloc de synchronisation pour voir ce qui se passe? UnIllegalMonitorStateException
sera levéeUne différence clé pas encore mentionné, c'est que pendant le sommeil d'un Thread ne pas libérer les verrous qu'il détient, en attendant libère le verrou sur l'objet qui
wait()
est appelé.synchronized(LOCK)
. La comparaison avec le code que vous avez fait ci-dessus est trompeur.sleep
détient java verrous, mais il ne le fait pas. Pour avoir une comparaison équitable, nous permettrait de comparersynchronized(OUTER_LOCK){ Thread.sleep(1000); }
avecsynchronized(OUTER_LOCK){ synchronized(LOCK){LOCK.wait();} }
et nous pouvons voir que les deux instructions ne relâchez pas laOUTER_LOCK
. Si il n'y a aucune différence, on peut dire quesleep
n'est pas explicitement utilisation java verrous, mais la question se pose au sujet de la citation "comment leur mise en œuvre varient à un niveau inférieur?" vulgaire.wait()
ne peut libérationLOCK
et pasOUTER_LOCK
. C'est la façon dont Java moniteur 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()
tiendra deux verrous tout enwait()
publieraLOCK
mais encore de les tenirOUTER_LOCK
J'ai trouvé ce post utile. Il met de la différence entre
Thread.sleep()
,Thread.yield()
, etObject.wait()
en termes humains. Pour citer:sleep(n)
est implicitement dire que le thread en cours d'exécution, elle abandonne le verrouillage du moniteur volontairement, ce qui est ce n'est pas vrai. Citation de Fil de la javadoc:"Le thread ne pas perdre la propriété de tous les moniteurs."sleep
ne pas avoir de comportement à l'égard de surveiller que tout autre méthode Java appel, qui est, il n'a pas d'interaction ou de les modifier en aucune façon. Si vous voulez dire quelque chose sur les moniteurs vous devez spécifier quewait
en plus de ce qui est dit ci-dessus, renoncer temporairement le verrou sur l'objet auquel il est appelé.Il y a beaucoup de réponses ici, mais je ne pouvais pas trouver la distinction sémantique mentionné sur tout.
Il n'est pas sur le fil lui-même; les deux méthodes sont tenus de soutenir les différents cas d'utilisation.
sleep()
envoie le Fil de dormir comme il était avant, c'est juste packs le contexte et s'arrête l'exécution pour une durée prédéfinie. C'est dans le but de le réveiller avant le temps, vous avez besoin de savoir le Fil de référence. Ce n'est pas une situation courante dans un environnement multi-thread. Il est principalement utilisé pour la synchronisation temporelle (par exemple, réveil exactement de 3,5 secondes) et/ou codée en dur de l'équité (juste dormir et de laisser les autres threads de travail).wait()
, au contraire, est un thread (ou message) mécanisme de synchronisation qui vous permet de notifier un Fil dont vous n'avez pas de référence stockée (ni de soins). Vous pouvez penser que c'est un publish-subscribe modèle (wait
== abonnez-vous etnotify()
== publier). Fondamentalement, l'aide notify() vous envoyez un message (qui pourrait même ne pas être reçu à tous et normalement vous n'avez pas de soins).Pour résumer, vous utilisez normalement
sleep()
pour le temps de synchronisation etwait()
pour le multi-thread-synchronisation.Ils pourraient être mises en œuvre de la même manière dans l'OS sous-jacent, ou pas du tout (comme les versions précédentes de Java n'avait pas vraiment de multithreading; probablement quelques petites VMs ne pas le faire). N'oubliez pas de Java s'exécute sur une machine virtuelle, de sorte que votre code sera transformé en quelque chose de différent en fonction de la VM/OS/HW, il fonctionne sur.
Ici, j'ai énuméré quelques différences importantes entre
wait()
etsleep()
méthodes.PS: Également cliquer sur le liens pour voir le code de bibliothèque (travail interne, il suffit de jouer autour un peu pour une meilleure compréhension).
wait()
wait()
méthode libère le verrou.wait()
est la méthode deObject
classe.wait()
est la non-méthode statique -public final void wait() throws InterruptedException { //...}
wait()
doit être notifiée parnotify()
ounotifyAll()
méthodes.wait()
méthode doit être appelée à partir d'une boucle pour traiter avec de la fausse alarme.wait()
méthode doit être appelée de façon synchronisée contexte (i.e. méthode synchronisée ou bloc), sinon il va jeterIllegalMonitorStateException
sleep()
sleep()
méthode de ne pas libérer 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é.sleep()
mieux ne pas appeler à partir de la boucle(c'est à dire voir code ci-dessous).sleep()
peut être appelée à partir de n'importe où. il n'y a pas d'exigence spécifique.Ref: Différence entre Attendre et de Sommeil
Extrait de Code pour l'appel d'attendre et de sommeil méthode
Thread.sleep()
est l'utilisation pour la fabrication de temps processeur disponible pour les autres threads. la période de sommeil peut être résilié par les interruptions(j'.e par la JVM). Lire ce stackoverflow.com/questions/4264355/...notifyAll()
sontObject
les méthodes de la classe. par conséquent, ils sont disponibles obj de l'ensemble de la classe(c'est à dire ici avecThread
classe trop). voir le code grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/...Il y a une différence clé de notes, j'ai conclure, après avoir travaillé sur d'attendre et de sommeil, tout d'abord un regard sur l'échantillon à l'aide wait() et sleep():
Exemple1: à l'aide de attendre() et sommeil():
Laisser la clarté de quelques notes clés:
S'il vous plaît corrigez-moi si je me trompe.
Différence entre wait() et sleep()
La différence fondamentale est que
wait()
est deObject
etsleep()
est une méthode statique deThread
.La différence majeure est que
wait()
libère le verrou tout ensleep()
ne dispense pas d'une écluse en attendant.wait()
est utilisé pour la communication inter-thread alors quesleep()
est utilisé pour introduire une pause sur l'exécution, en général.wait()
devrait être appelée à partir de l'intérieur de synchroniser ou d'autre, nous obtenons unIllegalMonitorStateException
, tandis quesleep()
peut être appelée n'importe où.wait()
, vous devez appelernotify()
ounotifyAll()
. Comme poursleep(),
le thread se met en marche après un intervalle de temps spécifié.Similitudes
C'est une question très simple, parce que ces deux méthodes ont une tout autre utilisation.
La différence majeure est d'attendre pour libérer le verrou ou le moniteur pendant le sommeil n'a pas communiqué d'une écluse ou un moniteur pendant l'attente. Attendre est utilisé pour la communication inter-thread pendant le sommeil est utilisé pour introduire une pause sur l'exécution.
C'était juste une manière claire et explication de base, si vous voulez plus de que puis continuer la lecture.
En cas de
wait()
méthode thread passe dans l'état d'attente et il ne reviendra pas automatiquement jusqu'à ce que nous appelons lanotify()
de la méthode (ounotifyAll()
si vous avez plus d'un thread en attente et vous voulez vous réveiller tous ceux thread). Et vous avez besoin synchronisé ou de l'objet de verrouillage ou de la classe de verrouillage pour accéder à lawait()
ounotify()
ounotifyAll()
méthodes. Et encore une chose, lawait()
méthode est utilisée pour la communication inter-thread parce que si un thread passe dans l'état d'attente, vous aurez besoin d'un autre thread pour réveiller ce fil.Mais dans le cas de
sleep()
c'est une méthode qui est utilisé pour maintenir le processus pour quelques secondes ou le temps que vous vouliez. Parce que vous n'avez pas besoin de provoquer unenotify()
ounotifyAll()
méthode pour obtenir ce thread en arrière. Ou vous n'avez pas besoin d'un autre thread pour rappeler ce thread. Comme si vous voulez quelque chose devrait se produire après quelques secondes comme dans un jeu après que l'utilisateur est au tour de vous souhaitez à l'utilisateur d'attendre jusqu'à ce que l'ordinateur joue, puis vous pouvez mentionner lesleep()
méthode.Et une importante différence qui est demandé souvent dans les entretiens:
sleep()
appartient àThread
classe etwait()
appartient àObject
classe.Ce sont toutes les différences entre
sleep()
etwait()
.Et il y a une similitude entre les deux méthodes: elles sont vérifiées déclaration si vous avez besoin d'essayer de l'attraper ou de lancers pour accéder à ces méthodes.
J'espère que cela va vous aider.
source : http://www.jguru.com/faq/view.jsp?EID=47127
Attendre et le sommeil sont deux choses différentes:
sleep()
le fil des arrêts de travail pour la durée spécifiée.wait()
le thread s'arrête de fonctionner jusqu'à ce que l'objet attendu est notifié, en général par d'autres threads.sleep
, si vous voulez que ça cesse jusqu'à ce que certaines d'entrée vient de l'autre vous utilisezwait
/notify
.interrupt
est conçu comme un moyen de signaler un thread qu'il devrait arrêter de faire ce qu'il fait et de se terminer. Il est géré parsleep
,wait
mais aussi le blocage des fonctions d'e/S (et vous pourriez mettre en œuvre des fonctions avec le même comportement en appelant la méthodeThread.interrupted()
). Comme pour les performances, les fonctions sont généralement optimisés pour l'objectif qu'ils ont été conçus.sleep
est une méthode deThread
,wait
est une méthode deObject
, doncwait/notify
est une technique de synchronisation des données partagées en Java (à l'aide de moniteur), maissleep
est une méthode simple de fil à suspendre.sleep() est une méthode qui est utilisé pour maintenir le processus pour quelques secondes ou le temps que vous voulais, mais en cas de wait() la méthode thread passe dans l'état d'attente et il ne reviendra pas automatiquement jusqu'à ce que nous appelons le notify() ou notifyAll().
La différence majeure est que wait() libère le verrou ou le moniteur pendant le sommeil() n'a pas de rejets d'une écluse ou un moniteur pendant l'attente. Attendre est utilisé pour la communication inter-thread pendant le sommeil est utilisé pour introduire une pause sur l'exécution, en général.
Fil.sleep() envoie le thread en cours dans l'état “Non Praticable” pour un certain laps de temps. Le thread conserve les analyses qu'il a acquis — c'est à dire si le thread est actuellement en parallèle, un bloc ou de la méthode aucun autre thread ne peut entrer dans ce bloc ou de la méthode. Si un autre thread appelle t.interrupt() il réveille le thread en sommeil. Notez que le sommeil est une méthode statique, ce qui signifie qu'il affecte toujours le thread courant (celui qui est de l'exécution de la méthode sleep). Une erreur commune est d'appeler t.sleep() où t est un thread différent; même alors, il est le fil qui va de sommeil, pas le t thread.
objet.wait() envoie le thread en cours dans l'état “Non Praticable”, comme le sommeil(), mais avec une torsion. Attendre est appelée sur un objet, pas un fil; nous appelons cet objet le “verrou de l'objet.” Avant de serrure.wait() est appelée, le thread courant doit se synchroniser sur le verrou de l'objet; wait() libère alors de ce verrou, et ajoute le fil de la “liste d'attente” associé à la serrure. Plus tard, un autre thread peut se synchroniser sur le même verrouillage de l'objet et l'appel de verrouillage.notify(). Cela réveille l'origine, thread en attente. Fondamentalement, wait()/notify() est comme le sommeil()/interrupt(), seul le thread actif, n'a pas besoin d'un pointeur direct vers le thread en sommeil, mais seulement pour le verrou partagé objet.
Laisser catégoriser tous les points ci-dessus :
Call on:
Synchronized:
Hold lock:
Wake-up condition:
Usage:
Ref:diff
sommeil
etwait
wait
etsleep
méthodes sont très différentes:sommeil
a aucun moyen de le "réveiller",wait
a une façon de "réveiller" au cours de la période d'attente, par un autre thread appelantnotify
ounotifyAll
.Venez pour penser à elle, ce sont les noms de confusion à cet égard; toutefois
sleep
est un nom standard etwait
est comme leWaitForSingleObject
ouWaitForMultipleObjects
dans la Victoire de l'API.En mots simples, l'attente est d'attendre Jusqu'à ce qu'un autre thread appelle vous alors que le sommeil est "ne pas exécuter l'instruction suivante" pour une certaine période de temps spécifiée.
En outre, le sommeil est une méthode statique dans la classe Thread et il fonctionne sur le fil, alors que le wait() est dans la classe d'Objet et appelée sur un objet.
Un autre point, lorsque vous l'appel en attente sur un objet, le thread en question synchroniser l'objet, puis attend. 🙂
De ce post : http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/
wait() de la Méthode.
1) Le thread qui appelle wait() la méthode libère le verrou qu'il détient.
2) Le fil reprend le verrou après les autres threads d'appel soit notify() ou notifyAll() méthodes sur la même serrure.
3) wait() la méthode doit être appelée dans le bloc synchronisé.
4) wait() la méthode est toujours appelée sur les objets.
5) les threads en Attente peut être réveillé par d'autres threads en appelant notify() ou notifyAll() méthodes.
6) À l'appel en attente() la méthode, le fil doit avoir un objet de verrouillage.
sleep() la Méthode
1) Le thread qui appelle sleep() la méthode de ne pas libérer le verrou qu'il détient.
2) dormir() la méthode peut être appelée à l'intérieur ou à l'extérieur du bloc synchronisé.
3) dormir() la méthode est toujours appelée sur les threads.
4) Dormir fils ne peut pas être réveillé par d'autres threads. Si fait, le thread va jeter InterruptedException.
5) À l'appel de méthode de sommeil (), le thread n'a pas besoin d'avoir un objet de verrouillage.
wait()
est une méthode deObject
classe.sleep()
est une méthode deThread
classe.sleep()
permet le fil pour aller àsleep
de l'état pour les x millisecondes.Lorsqu'un thread passe dans l'état de sommeil
it doesn’t release the lock
.wait()
permet thread pour libérer le verrou etgoes to suspended state
.Ce fil sera actif quand une
notify()
ounotifAll()
méthode estappelé pour le même objet.
Une grande différence entre le sommeil/interruption et wait/notify est que
interrupt()
pendantsleep()
toujours déclenche une exception (par exemple,InterruptedException), alors quenotify()
pendantwait()
ne pas.Générer une exception lorsqu'il n'est pas nécessaire est inefficace. Si vous avez des threads de communiquer les uns avec les autres à un rythme élevé, alors il serait de générer beaucoup d'exceptions si vous étiez en appelant interrompre tout le temps, ce qui est un gaspillage total de CPU.
Vous sont corrects - Sleep() provoque ce thread en "sommeil" et le CPU vont traiter d'autres threads (autrement connu comme la commutation de contexte) wheras je pense Attendre maintient le PROCESSEUR de traitement du thread courant.
Nous avons à la fois parce que même si il peut sembler judicieux de laisser d'autres personnes utiliser le CPU alors que vous ne l'utilisez pas, effectivement il existe une surcharge de la commutation de contexte - en fonction de combien de temps le sommeil, il peut être plus cher dans les cycles CPU pour passer de threads que c'est pour tout simplement avoir votre fil ne rien faire pendant quelques ms.
Notez également que les forces du sommeil d'un changement de contexte.
Aussi - en général, il n'est pas possible de contrôler la commutation de contexte - lors de l'Attente, l'OS peut (et pour une plus longue attente) le choix de traiter les autres threads.
Les méthodes sont utilisées pour différentes choses.
Fil.sleep(n) peut être interrompu, mais de l'Objet.wait() doit être notifié.
Il est possible de spécifier la durée maximale d'attente:
Object.wait(5000)
de sorte qu'il serait possible d'utiliserwait
à, er,sleep
mais alors vous avez de la peine avec les verrous.Aucune de ces méthodes utilise le processeur pendant le sommeil/en attente.
Les méthodes sont implémentées à l'aide de code natif, à l'aide d'autres constructions similaires, mais pas de la même façon.
Regardez par vous-même: Le code source natif de méthodes disponibles? Le fichier
/src/share/vm/prims/jvm.cpp
est le point de départ...Ici wait() sera dans l'état d'attente jusqu'à ce qu'il notifie par un autre Thread mais où que sleep() va avoir un peu de temps..après cela, il sera automatiquement transféré à l'état Prêt...
Wait() et sleep() Différences?
Fil.sleep()
Une fois son travail terminé, puis seulement sa sortie de l'écluse à tout le monde. jusqu'à son ne jamais relâcher le verrou à personne.
Objet.wait()
Quand sa va une phase d'attente, sa sera la libération de la clé et de son attente pour quelques secondes en fonction du paramètre.
Par Exemple:
vous prendre le café dans le vôtre main droite, vous pouvez prendre une autre personne de la même main, quand serez-vous mettre vers le bas, puis seulement prendre un autre objet de même type. aussi. c'est un sleep()
vous avez le temps de sommeil que vous n'avez pas tout le travail, vous ne faire que dormir.. même ici aussi.
wait(). lorsque vous êtes mis bas et en prendre une autre moyenne pendant que vous attendez , c'est d'attendre
vous lire la vidéo ou quoi que ce soit dans le vôtre système même en tant que joueur, vous ne pouvez pas jouer plus d'un à la fois à droite, c'est ici, que lorsque vous fermez et de choisir une autre personne film ou la chanson s'est appelé attente
wait
libère le verrou etsleep
ne l'est pas. Un thread en attente de l'état est admissible à se réveiller dès quenotify
ounotifyAll
est appelé. Mais dans le cas desleep
le thread conserve la serrure, et il va seulement être admissible, une fois que le temps de sommeil est plus.InterruptedException
est jeté, comme il est dit dans la Javadoc.sleep()
méthode provoque le thread courant de passer de l'exécution de l'état pour bloquer l'état pour une période de temps spécifiée. Si le thread courant a l'écluse de n'importe quel objet, alors il tient, ce qui signifie que les autres threads ne peuvent exécuter n'importe quelle méthode synchronisée dans la classe de l'objet.wait()
méthode provoque le thread courant pour aller dans le bloc de l'etat, soit pour une période déterminée ou jusqu'à l'informer, mais dans ce cas, le thread libère le verrou de l'objet (ce qui signifie que les autres threads peuvent exécuter tout synchronisé méthodes de l'objet appelant.À mon avis, la principale différence entre les deux mécanismes est que le sommeil/interruption est la façon la plus simple de manipulation de threads, alors que wait/notify est une abstraction visant à faire thread inter-communication plus facile. Cela signifie que le sommeil/interruption peut rien faire, mais que cette tâche est plus difficile à faire.
Pourquoi est-wait/notify plus adapté? Voici quelques considérations personnelles:
Il renforce la centralisation. Il permet de coordonner la communication entre un groupe de threads avec un seul objet partagé. Cela simplifie le travail de beaucoup.
Il applique la synchronisation. Parce qu'il fait le programmeur placer l'appel en attente/avertir dans un bloc synchronisé.
Il est indépendant de la thread d'origine et le numéro. Avec cette approche, vous pouvez ajouter plus de threads de manière arbitraire, sans modifier les autres threads ou de garder une trace de celles déjà existantes. Si vous avez utilisé le sommeil/interrompre, d'abord vous devez garder les références à la couchette du fils, et puis interrompre un par un, à la main.
Un exemple de la vie réelle qui est bon pour expliquer ce que c'est un restaurant classique et la méthode que le personnel de l'utiliser pour communiquer entre eux: Les serveurs de quitter les demandes des clients dans un endroit central (un tableau de liège, une table, etc.), sonner une cloche, et les travailleurs de la cuisine viennent pour prendre de telles demandes. Une fois qu'il est tout prêt, la cuisine, le personnel de sonner la cloche à nouveau de sorte que les serveurs sont conscients et prennent à la clientèle.
Exemple sur le sommeil n'a pas communiqué de serrure et attendre ne
Ici il y a deux classes :
Singleton : C'est classe singleton avec deux méthodes statique getInstance() et getInstance(boolean isWait).
et
Maintenant exécuter cet exemple, vous obtiendrez en dessous de sortie :
Ici Singleton instances créées par threadA et threadB sont les mêmes. Cela signifie threadB est en attente à l'extérieur jusqu'à threadA la libérer de la serrure.
Maintenant de modifier la Singleton.java en commentant Fil.sleep(500); la méthode et de décommenter Singleton.classe.attendre(500); . Ici, en raison de Singleton.classe.attendre(500); méthode threadA libère toute acquisition de verrous et se déplace dans la “Non Praticable” de l'état, threadB obtiendrez changer pour entrer dans le bloc synchronisé.
Maintenant, exécutez de nouveau :
Ici Singleton instances créées par threadA et threadB ne sont PAS les mêmes en raison de threadB ai changer pour entrer dans synchronisée bloc et après 500 millisecondes threadA commencé à partir de sa dernière position et créé plus d'objet Singleton.
Doit être appelée de façon synchronisée bloc :
wait()
méthode est toujours appelée de façon synchronisée bloc c'est à direwait()
méthode de verrouillage de l'objet à l'écran avant de l'objet sur lequel elle est appelée. Maissleep()
méthode peut être appelée de l'extérieur synchronisé bloc c'est à diresleep()
méthode n'a pas besoin de tout objet à surveiller.IllegalMonitorStateException : si
wait()
méthode est appelée sans l'acquisition de l'objet de verrouillage deIllegalMonitorStateException
est levée lors de l'exécution, maissleep()
méthode jette jamais une telle exception.Appartient à la classe :
wait()
méthode appartient àjava.lang.Object
classe maissleep()
méthode appartient àjava.lang.Thread
classe.Appelée sur l'objet ou le fil :
wait()
méthode est appelée sur les objets, maissleep()
méthode est appelée sur les Threads sont pas des objets.État du Thread : quand
wait()
méthode est appelée sur l'objet, le fil que repliée objet du moniteur va partir en cours d'exécution à l'état d'attente et peuvent retourner à l'état exécutable uniquement lorsquenotify()
ounotifyAll()
méthode est appelée sur l'objet. Et plus tard planificateur de threads horaires de ce thread pour aller à partir de praticable à l'état en cours d'exécution.lorsque
sleep()
est appelée sur le thread, il va partir en cours d'exécution à l'état d'attente et peuvent retourner à l'état exécutable lorsque le temps de sommeil est en place.Lorsqu'il est appelé de façon synchronisée bloc : quand
wait()
méthode est appelée fil des feuilles de l'objet de verrouillage. Maissleep()
méthode lorsqu'elle est appelée de façon synchronisée bloc ou de la méthode thread n'a pas de feuilles objet de verrouillage.Pour Plus D' Référence
À partir d'oracle page de documentation sur wait() méthode de
Object
:notify()
méthode ou lanotifyAll()
méthode de cet objet. En d'autres termes, cette méthode se comporte exactement comme si simplement, il effectue l'appelwait(0)
.Cette méthode lève
IllegalMonitorStateException
- si le thread actuel n'est pas le propriétaire de l'objet du moniteur.InterruptedException
- si n'importe quel thread interrompu le thread courant avant ou pendant que le thread courant a été en attente d'une notification. L'état d'interruption du thread actuel est effacé lorsque cette exception est levée.À partir d'oracle page de documentation sur sleep() méthode de
Thread
classe:Cette méthode lève:
IllegalArgumentException
- si la valeur de millis est négatifInterruptedException
- si un thread a été interrompu le thread courant. L'état d'interruption du thread actuel est effacé lorsque cette exception est levée.Autre différence clé:
wait()
est un non-static method (méthode d'instance) contrairement à la méthode statiquesleep()
(méthode de classe).wait()
est donné à l'intérieur d'une méthode synchroniséealors que
sleep()
est donné à l'intérieur d'une non-méthode synchronisée, carwait()
méthode de libérer le verrou sur l'objet, maissleep()
ouyield()
ne relâchez lelock()
.sleep()
peut être à l'intérieur d'unsynchronized
bloc ou de la méthode. La réponse n'explique rien.attendre avec une valeur de délai d'expiration peut réveil sur une valeur de timeout écoulé ou de notification si elle est antérieure (ou d'interrompre ainsi, alors que le sommeil se réveille sur la valeur du délai écoulé ou d'une interruption de ces éventualités. wait() et n'a pas valeur de délai d'expiration attendra jamais jusqu'à avis ou interrompu
wait(1000)
le thread actuel de dormir jusqu'à une seconde.notify()
ounotifyAll()
appel de méthode.sleep(1000)
le thread actuel de sommeil pour exactement 1 seconde.sleep(1000)
n'est pas garantie pour dormir pendant exactement 1 seconde. Il peut peut être interrompu avant.En fait, tout cela est clairement décrit dans Java docs (mais je l'ai compris qu'après avoir lu les réponses).
http://docs.oracle.com/javase/8/docs/api/index.html :
wait() - Le thread courant doit être propriétaire de cet objet à l'écran. Le thread libère
la propriété de ce moniteur et attend jusqu'à ce qu'un autre thread informe
les threads en attente sur cet objet du moniteur de réveil, soit par l'intermédiaire d'un
appel à la méthode de notification ou de la méthode notifyAll. Le thread
attend jusqu'à ce qu'il peut obtenir de nouveau la propriété de la surveiller et reprend l'exécution.
sleep() - Provoque le thread en cours d'exécution pour le sommeil (de cesser temporairement l'exécution) pour le nombre de millisecondes spécifié, sous réserve de la précision et de l'exactitude du système de minuteries et des planificateurs. Le thread ne pas perdre la propriété de tous les moniteurs.
Permet de supposer que vous entendez des chansons.
Aussi longtemps que la chanson est en cours d'exécution, le morceau suivant l'habitude de jouer, j'.e Sleep() appelée par la chanson suivante
Si vous avez fini la chanson, il s'arrête, et jusqu'à ce que vous sélectionnez le bouton de lecture(notify()) il l'habitude de jouer, j'.e wait() appelée par la chanson actuelle.
Dans ce les deux cas, chansons vont états d'Attente.