Différence entre wait () et sleep()

une différence clé pas encore mentionnée est que pendant le sommeil un fil ne pas libérer les serrures qu'il détient, tandis que l'attente libère la serrure sur l'objet que wait() est appelé.

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


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

j'ai trouvé ce lien utile (qui se réfère à ce post ). Il met la différence entre sleep() , wait() , et yield() en termes humains. (dans le cas où les liens jamais mort j'ai inclus le post ci-dessous avec un supplément supplémentaire)

tout finit par arriver à l'ordonnanceur de L'OS, qui donne des délais aux processus et aux threads.

sleep(n) dit "je suis fait avec mon timeslice, et merci de ne pas me donner un autre pendant au moins n millisecondes." L'OS n'a même pas essayer de programmez le fil de nuit jusqu'à ce que le temps demandé soit passé.

yield() dit "je suis fait avec mon timeslice, mais j'ai encore du travail à faire." L'OS est libre immédiatement donnez au fil un autre timeslice, ou de donner un autre fil ou de traiter le CPU le fil de cédage simplement abandonné.

.wait() dit "je suis fait avec mon timeslice. Ne me donnez pas un autre timeslice jusqu'à ce que quelqu'un appelle notify()." comme avec sleep() , L'OS ne même essayer de planifier votre tâche à moins que quelqu'un appelle notify() (ou l'un des quelques autres scénarios de réveil se produisent).

Threads aussi perdre le reste de leur timeslice quand ils effectuent bloquant IO et dans quelques autres circonstances. Si un thread fonctionne tout au long de la chaîne de temps, L'OS prend le contrôle de force à peu près comme si yield() avait été appelé, pour que d'autres processus puissent fonctionner.

vous avez rarement besoin de yield() , mais si vous avez une application Compute-heavy avec les limites logiques des tâches, en insérant un yield() pourrait améliorer système la réactivité (au détriment des commutateurs temps-contexte, même juste à L'OS et retour, ne sont pas libres). Mesurer et tester par rapport à vos objectifs de soins, comme toujours.

il y a beaucoup de réponses ici, mais je n'ai pas pu trouver la distinction sémantique mentionnée sur aucune.

il ne s'agit pas du thread lui-même; les deux méthodes sont nécessaires car elles supportent des cas d'utilisation très différents.

sleep() envoie le Thread pour dormir comme il était avant, il emballe juste le contexte et arrête l'exécution pour un temps prédéfini. Donc, afin de le réveiller avant le moment opportun, vous avez besoin de connaître la référence du Thread. Ce n'est pas une commune situation dans un environnement multi-thread. Il est principalement utilisé pour la synchronisation du temps (par exemple wake en exactement 3.5 secondes) et/ou l'équité codée dur (juste dormir pendant un certain temps et laisser les autres fils de travail).

wait() , au contraire, est un mécanisme de synchronisation de thread (ou 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 et notify() = = publier.) Essentiellement 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 sleep() pour la synchronisation temporelle et wait() pour la synchronisation multi-thread.

ils pourraient être implémentés de la même manière dans le système d'exploitation sous-jacent, ou pas du tout (comme les versions précédentes de Java n'avaient pas de véritable multithreading; probablement que certains petits VMs ne le font pas non plus). Ne pas oubliez Java tourne sur une VM, votre code sera donc transformé en quelque chose de différent selon la VM/OS/HW sur laquelle il tourne.

J'ai énuméré ici quelques différences importantes entre les méthodes wait() et sleep() .

PS: Cliquez également sur les liens pour voir le code de la bibliothèque (travail interne, il suffit de jouer un peu pour une meilleure compréhension).

wait ()

1. wait() la méthode libère la serrure.
2. wait() est la méthode de la classe Object .
3. wait() est la méthode non statique- public final void wait() throws InterruptedException { //...}
4. wait() doit être notifié par les méthodes notify() ou notifyAll() .
La méthode

5. wait() doit être appelée à partir d'une boucle afin de traiter la fausse alarme.

6. wait() la méthode doit être appelée à partir du contexte synchronisé (i.e. méthode ou bloc synchronisé), sinon il lancera IllegalMonitorStateException

sleep ()

1. sleep() ne libère pas la serrure.
2. sleep() est la méthode de la classe java.lang.Thread .
3. sleep() est la méthode statique - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. après le moment déterminé, sleep() correspond à ce qui suit: compléter.
5. sleep() mieux vaut ne pas appeler de la boucle(i.e. voir le code ci-dessous ).
6. sleep() peut être appelé de n'importe où. il n'y a pas d'exigence spécifique.

Réf: différence entre L'attente et le sommeil

extrait de Code pour l'appel d'attendre et de méthode sleep

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

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

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

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

Laissez-la clarté de certaines des principales notes:

1. Appel à :
   • wait(): Appel sur le thread en cours qui détiennent HandObject Objet
   • sleep(): Appel sur le Thread d'exécution de la tâche d'obtenir de la bière (est de la méthode de classe affectent donc sur le thread en cours d'exécution)
2. synchronisé :
   • wait (): en cas de synchronisation multi-thread accès au même objet (HandObject) (en cas de besoin de communication entre plus d'un thread (thread execute coding, thread execute get beer) accès au même objet HandObject )
   • sleep(): lors de l'attente de la condition de continuer à exécuter (en Attente de la bière disponible)
3. Maintenez le verrou :
   • wait(): libère le verrou pour d'autres objets ont de la chance d'exécution (HandObject est libre, vous pouvez faire d'autres emplois)
   • sleep(): garder le verrou d'au moins t de temps (ou jusqu'à ce que l'interruption) (Mon travail pas encore fini, je vais continuer maintenez le verrou et en attendant le condition pour continuer)
4. le Réveil de la condition :
   • wait(): jusqu'à appeler notify(), notifyAll() de l'objet
   • sleep(): au moins jusqu'au moment d'expirer ou call interrompre
5. et le dernier point est utiliser quand comme estani indiquer:

vous utilisez normalement sleep() pour Time-syncronisation et wait () pour synchronisation multi-thread.

corrigez-moi si je me trompe.

Différence entre wait() et sleep()

• la différence fondamentale est wait() est de Object et sleep() est la méthode statique de Thread .

• la différence majeure est que wait() libère la serrure alors que sleep() ne libère AUCUNE serrure en attendant.

• le wait() est utilisé pour la communication inter-thread tandis que sleep() est utilisé pour introduire une pause sur l'exécution, en général.

• le wait() devrait appeler de l'intérieur synchroniser ou bien nous obtenons IllegalMonitorStateException tandis que sleep() peut appeler n'importe où.

• pour redémarrer le fil à partir de wait() , vous devez appeler notify() ou notifyAll() . Alors que dans sleep(), le fil commence après avoir spécifié ms/sec d'intervalle.

similitudes qui aident à comprendre

• les deux fait le fil courant va dans le Non Runnable état.
• les deux méthodes sont native .

C'est une question très simple, parce que ces deux méthodes ont une tout autre utilisation.

la principale différence est d'attendre pour déverrouiller la serrure ou le moniteur pendant le sommeil ne déverrouille pas la serrure ou le moniteur pendant l'attente. Wait est utilisé pour la communication inter-thread tandis que sleep est utilisé pour introduire une pause sur l'exécution.

c'était juste une explication claire et basique, si vous voulez plus que cela alors continuer la lecture.

dans le cas de wait() le thread de méthode va dans l'état d'attente et il ne reviendra pas automatiquement jusqu'à ce que nous appelions la méthode notify() (ou notifyAll() si vous avez plus d'un thread dans l'état d'attente et vous voulez réveiller tous ces thread). Et vous avez besoin d'un verrouillage synchronisé ou objet ou d'un verrouillage de classe pour accéder aux méthodes wait() ou notify() ou notifyAll() . Et encore une chose ,la méthode wait() est utilisée pour le filetage communication parce que si un thread va dans l'état d'attente vous aurez besoin d'un autre thread pour réveiller ce thread.

Mais en 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 une méthode notify() ou notifyAll() pour récupérer ce fil. Ou vous n'avez pas besoin d'un autre fil pour rappeler ce fil. Comme si vous voulez quelque chose devrait se produire après quelques secondes comme dans un jeu après tour de l'utilisateur vous voulez que l'utilisateur attende jusqu'à ce que l'ordinateur joue alors vous pouvez mentionner la méthode sleep() .

et une autre différence importante qui est souvent demandée dans les interviews: sleep() appartient à la classe Thread et wait() appartient à la classe Object .

ce sont toutes les différences entre sleep() et wait() .

et il y a une similitude entre les deux méthodes: elles sont toutes les deux vérifié la déclaration donc vous avez besoin d'essayer attraper ou jette pour accéder à ces méthodes.

j'espère que cela vous aidera.

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

Thread.sleep() envoie le fil courant dans l'état " Non exécutable " pour un certain laps de temps. Le fil garde les moniteurs qu'il a acquis -- i.e. si le thread est actuellement dans un bloc synchronisé ou une méthode, aucun autre thread ne peut entrer dans ce bloc ou cette méthode. Si un autre fil appelle t.interrupt() il réveillera le fil de couchage.

notez que le sommeil est une méthode statique, ce qui signifie qu'il affecte toujours le fil courant (celui qui exécute la méthode sleep). Un erreur commune est d'appeler t.sleep() où t est un thread différent; même alors, c'est le fil courant qui dormira, pas le fil T.

t.suspend() est déprécié. Il est possible de arrêt d'un thread autre que le thread courant. Un fil suspendu garde tous ses moniteurs et comme cet état n'est pas interruptible, il est enclin à l'impasse.

object.wait() envoie le fil courant dans l'état " Non exécutable " , comme sleep() , mais avec une torsion. Attendre est appelée sur un objet, pas un thread; nous appelons cet objet " lock object."Avant lock.wait() est appelé, le fil courant doit synchroniser sur l'objet lock; wait() puis libère cette serrure, et ajoute le thread à la "liste d'attente"" associé avec la serrure. Plus tard, un autre fil peut se synchroniser sur le même serrure et appel lock.notify() . Cela réveille l'original, thread en attente. Fondamentalement, wait() / notify() est comme sleep() / interrupt() , seul le fil actif n'a pas besoin d'un fil direct pointeur vers le fil dormant, mais seulement vers l'objet de verrouillage partagé.

L'attente et le sommeil sont deux choses différentes:

• dans sleep() le fil arrête de fonctionner pendant la durée spécifiée.
• dans wait() le thread cesse de fonctionner jusqu'à ce que l'objet attendu soit notifié, généralement par d'autres threads.

sleep est une méthode de Thread , wait est une méthode de Object , donc wait/notify est une technique de synchronisation des données partagées en Java (en utilisant monitor ), mais sleep est une méthode simple de fil pour s'arrêter.

sleep () est une méthode qui est utilisée pour retenir le processus pendant quelques secondes ou le temps que vous vouliez mais en cas d'attente() le thread de méthode va dans l'état d'attente et il ne reviendra pas automatiquement jusqu'à ce que nous appelions le notify() ou notifyAll().

la principale différence est que wait () libère le cadenas ou le moniteur pendant le sommeil() ne libère aucun cadenas ou moniteur pendant l'attente. Attendre est utilisé pour la communication inter-thread alors que le sommeil est utilisé pour introduire une pause sur l'exécution, généralement.

Thread.sleep () envoie le thread courant dans l'état" non Runnable " pendant un certain temps. Le thread conserve les moniteurs qu'il a acquis - i.e. si le thread est actuellement dans un bloc synchronisé ou une méthode aucun autre thread ne peut entrer dans ce bloc ou cette méthode. Si un autre fil appelle T. interrompre () il va réveiller le fil de sommeil. Notez que le sommeil est une méthode statique, ce qui signifie qu'elle affecte toujours le fil courant (celui qui exécute la méthode sleep). Une erreur courante est d'appeler T. sleep() où t est un fil différent; même alors, c'est le fil courant qui dormira, pas le fil T.

objet.wait () envoie le thread courant dans l'état "non Runnable", comme sleep(), mais avec une torsion. Wait est appelé sur un objet, pas un thread; nous appelons cet objet " lock object." Avant de serrure.wait() est appelé, le thread courant doit se synchroniser sur l'objet lock; wait() libère alors cette serrure, et ajoute le thread à la "liste d'attente" associée à la serrure. Plus tard, un autre thread peut se synchroniser sur le même objet lock et Call lock.notifier.)( Cela réveille le fil d'attente original. Fondamentalement, wait ()/notify () est comme sleep () / interrupt (), seul le thread actif n'a pas besoin d'un pointeur direct vers le thread de sommeil, mais seulement vers l'objet shared lock.

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

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

catégorisons tous les points ci-dessus:

Call on:

• wait (): appel sur un objet; le thread courant doit se synchroniser sur l'objet lock.
• sleep(): Appel qu'à un Fil; toujours thread en cours d'exécution.

Synchronized:

• attendre(): lorsque plusieurs threads sont synchronisés, accédez au même objet un par un.
• sleep(): lors d'une synchronisation de plusieurs threads attendre pour dormir du sommeil du fil.

Hold lock:

• wait (): relâchez la serrure pour que d'autres objets aient la chance de s'exécuter.
• sleep(): garder serrure à moins t fois si le délai spécifié ou quelqu'un d'interruption.

Wake-up condition:

• wait(): jusqu'à ce que l'appel notify(), notifyAll() de l'objet
• sleep(): au moins jusqu'au moment d'expirer ou d'interruption call().

Usage:

• sleep (): for le temps de synchronisation; et
• wait(): pour le multi-thread-synchronisation.

Réf: diff sleep et wait

wait et sleep sont très différentes:

• sleep n'a aucun moyen de "se réveiller",
• alors que wait a une façon de "se réveiller" pendant la période d'attente, par un autre fil appelant notify ou notifyAll .

venu à y réfléchir, le les noms prêtent à confusion à cet égard; toutefois, sleep est un nom standard et wait est comme WaitForSingleObject ou WaitForMultipleObjects dans L'API Win.

en termes simples, attendre est attendre Jusqu'à ce qu'un autre fil vous invoque alors que le sommeil est" dont execute next statement " pour une période de temps spécifiée.

de plus, sleep est une méthode statique dans la classe Thread et elle fonctionne sur thread, tandis que wait() est dans la classe Object et fait appel à un objet.

autre point, lorsque vous appelez wait sur un objet, le thread impliqué synchronise l'objet et attend ensuite. :)

à Partir de ce post : http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

wait() de la Méthode.

1) la méthode thread qui appelle wait () libère la serrure qu'elle contient.

2) le thread récupère la serrure après que les autres threads appellent les méthodes notify () ou notifyAll () sur la même serrure.

3) la méthode wait () doit être appelée dans la synchronie bloc.

4) la méthode wait () est toujours appelée sur les objets.

5) les threads D'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 (), thread must have object lock.

sleep() la Méthode

1) la méthode thread qui appelle sleep () ne libère pas la serrure qu'elle contient.

2) la méthode de sommeil () peut être appelée dans ou en dehors du bloc synchronisé.

3) la méthode sleep () est toujours appelée sur les fils.

4) Les fils qui dorment ne peuvent pas être réveillés par d'autres fils. Si cela est fait, thread lancera InterruptedException.

5) pour appeler la méthode sleep (), thread ne doit pas avoir de verrouillage d'objet.

sommeil

• il provoque le fil courant d'exécution de dormir pour une période de temps spécifique.
• sa précision dépend des minuteries et des ordonnanceurs du système.
• il garde les moniteurs qu'il a acquis, donc s'il est appelé de contexte synchronisé, aucun autre thread ne peut entrer dans ce bloc ou cette méthode.
• si nous appelons la méthode interruption (), elle se réveillera le thread en sommeil.

Attendre

• il provoque le fil courant d'attendre jusqu'à ce que l'un ou l'autre fil invoque la méthode notify () ou la méthode notifyAll() pour cet objet
• il doit être appelé du contexte synchronisé c.-À-D. du bloc ou méthode.Cela signifie qu'avant que la méthode wait() soit appelée, le thread courant doit verrouillez cet objet.
• Il libère le verrou sur l'objet sur lequel il est appelé et a ajouté liste d'attente, de sorte qu'un autre thread peut acquérir le verrouillage sur l'objet.

1. wait() est une méthode de la classe Object .
   
   sleep() est une méthode de la classe Thread .

2. sleep() permet au fil de passer à l'état sleep pendant x millisecondes.
   
   Quand un fil entre dans l'état de sommeil it doesn’t release the lock .

3. wait() permet au fil de déverrouiller la serrure et goes to suspended state .
   
   Ce thread sera actif lorsqu'une méthode notify() ou notifAll() est appelé pour le même objet.

une grande différence potentielle entre sommeil / interruption et attente / notification est que

• appel interrupt() pendant sleep() toujours déclenche une exception (par exemple, InterruptedException ), alors que le
• appel notify() pendant wait() ne fonctionne pas.

Générer une exception quand elle n'est pas nécessaire est inefficace. Si vous avez des threads qui communiquent entre eux à un taux élevé, alors cela générerait beaucoup d'exceptions si vous appeliez interrompre tout le temps, ce qui est un gaspillage total de CPU.

Vous avez raison - le 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 les deux parce que bien qu'il puisse sembler raisonnable de laisser d'autres personnes utiliser le CPU alors que vous ne l'utilisez pas, en fait il ya un rétroprojecteur à la commutation de contexte - selon combien de temps le sommeil est pour, il peut être plus coûteux dans les cycles CPU à changez les threads qu'il est de simplement avoir votre thread ne faisant rien pour quelques ms.

également noter que le sommeil oblige un commutateur de contexte.

aussi - en général il n'est pas possible de contrôler la commutation de contexte - pendant l'attente L'OS peut (et va pour les plus longues attentes) choisir de traiter d'autres threads.

Les méthodes sont utilisées pour différentes choses.

Thread.sleep(5000);   // Wait until the time has passed.

Object.wait();        // Wait until some other thread tells me to wake up.

Thread.sommeil (n) peut être interrompu, mais objet.wait() doit être informé. Il est possible de spécifier le temps maximum d'attente: Object.wait(5000) de sorte qu'il serait possible d'utiliser wait pour, euh, sleep , mais alors vous devez vous soucier des serrures.

aucune des méthodes n'utilise le cpu pendant le sommeil/l'attente.

les méthodes sont implémentées en utilisant le code natif, en utilisant des constructions similaires mais pas de la même manière.

Regardez par vous-même: Est 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 fil, mais où as sleep () aura un certain temps..après cela, il sera automatiquement transféré à l'état Prêt...

Wait() et sleep() Différences?

Thread.dormir() Une fois son travail terminé, il ne libère la serrure à tout le monde. jusqu'à ce qu'il ne libère jamais la serrure à personne.

  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.

objet.attendre() Quand il va à l'étape d'attente, its sera libérer la clé et son attente pendant certaines des secondes en fonction du paramètre.

Par Exemple:

vous êtes prendre le café dans la vôtre droite main, vous pouvez prendre un autre n'importe qui de la même main, quand votre poser alors seulement prendre un autre objet du même type ici. également. c'est le sommeil() vous ne travaillez pas, vous ne faites que dormir.. même chose ici aussi.

wait (). quand vous êtes couché et prendre un autre moyen pendant que vous attendez , c'est attendre

vous êtes film de jeu ou quoi que ce soit dans le vôtre système même que le joueur vous ne pouvez pas jouer plus d'un à la fois droit, c'est son ici, quand vous fermez et choisissez un autre n'importe qui film ou chanson moyen alors qu'est appelé wait

wait libère la serrure et sleep ne le fait pas. Un fil dans l'état d'attente est éligible pour se réveiller dès que notify ou notifyAll est appelé. Mais dans le cas de sleep le fil garde la serrure et il ne sera éligible qu'une fois le temps de sommeil est terminé.

sleep() fait passer le thread courant de l'état courant à l'état de bloc pour une durée spécifiée. Si le thread courant a le verrou de n'importe quel objet alors il le maintient, ce qui signifie que les autres threads ne peuvent pas exécuter n'importe quelle méthode synchronisée dans cet objet de classe.

wait() fait passer le thread courant dans l'état de bloc soit pour une durée spécifiée, soit jusqu'à notification, mais dans ce cas le thread libère la serrure 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/l'interruption est la façon la plus basique de gérer les threads, tandis que wait/notify est une abstraction visant à faciliter l'inter-communication des threads. cela signifie que le sommeil/l'interruption peut faire n'importe quoi, mais que cette tâche spécifique est plus difficile à faire.

pourquoi l'attente / notification est-elle plus appropriée? Voici quelques considérations personnelles:

1. il renforce la centralisation. Il permet de coordonner la communication entre un groupe de threads avec un seul objet partagé. Cela simplifie beaucoup le travail.

2. il assure la synchronisation. parce qu'il fait le programmeur envelopper l'appel à attendre/notifier dans un bloc synchronisé.

3. c'est indépendant de l'origine et du nombre du fil. avec cette approche, vous pouvez ajouter plus de threads arbitrairement sans éditer les autres threads ou garder une trace des threads existants. Si vous avez utilisé sommeil/interruption, vous devez d'abord garder les références aux fils de sommeil, puis les interrompre un par un, à la main.

un exemple de la vie réelle qui est bon à expliquer c'est un restaurant classique et la méthode que le personnel utilise pour communiquer entre eux: le les serveurs laissent les demandes du client dans un endroit central (une planche de Liège, une table, etc.), sonner une cloche, et les travailleurs de la cuisine viennent pour prendre de telles demandes. Une fois que le cours est prêt, le personnel de la cuisine sonne à nouveau pour que les serveurs soient au courant et les amènent aux clients.

exemple à propos du sommeil ne relâche pas la serrure et attend

il y a ici deux classes:

1. Main : contient la méthode principale et deux fils.

2. Singleton : c'est la classe singleton avec deux méthodes statiques getInstance() et 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();
   
    }
   }
   

et

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;

 }
}

maintenant, exécutez cet exemple vous obtiendrez la sortie suivante:

_instance :null
Both singleton are same

ici, les instances uniques créées par threadA et threadB sont les mêmes. Ça veut dire que threadB attend dehors jusqu'à ce que threadA le libère.

changez le Singleton.java en commentant Fil.sleep(500); la méthode et de décommenter Singleton.classe.attendre(500); . Ici à cause de Singleton.classe.wait (500); la méthode threadA va libérer toutes les serrures acquérir et les mouvements dans l'état" Non Runnable", threadB obtiendra un changement pour entrer dans le bloc synchronisé.

Maintenant, exécutez de nouveau :

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

ici, les instances uniques créées par threadA et threadB ne sont pas les mêmes à cause de threadB a obtenu un changement à entrer dans le bloc synchronisé et après 500 millisecondes, threadA a commencé à partir de sa dernière position et a créé un objet unique de plus.

doit être appelé du bloc synchronisé: wait() la méthode est toujours appelée du bloc synchronisé i.e. wait() la méthode doit verrouiller le moniteur d'objet avant l'objet sur lequel elle est appelée. Mais la méthode sleep() peut être appelée de l'extérieur du bloc synchronisé, c'est-à-dire que la méthode sleep() n'a pas besoin de moniteur objet.

IllegalMonitorStateException: si wait() méthode est appelée sans acquisition de verrouillage d'objet que IllegalMonitorStateException est lancé à l'exécution, mais la méthode sleep() ne jette jamais une telle exception.

appartient à quelle classe: wait() méthode appartient à java.lang.Object classe mais sleep() méthode appartient à java.lang.Thread classe.

appelé sur l'objet ou le fil: wait() méthode est appelé sur les objets, mais sleep() méthode est appelé sur les fils Non objet.

Fil de l'etat : quand wait() la 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 lorsque notify() ou notifyAll() la méthode est appelée sur l'objet. Et plus tard, les horaires de thread scheduler qui vont de l'état runnable à l'état running. quand sleep() est appelé sur thread, il passe de running à waiting state et peut revenir à état exécutable lorsque le temps de sommeil est en place.

lorsqu'on l'appelle du bloc synchronisé: lorsque la méthode wait() s'appelle thread leaves the object lock. Mais la méthode sleep() lorsqu'elle est appelée à partir d'un bloc synchronisé ou d'un thread de méthode ne laisse pas l'objet verrouillé.

Pour Plus Référence

De l'oracle page de documentation sur wait() méthode de Object :

public final void wait()

1. fait attendre le fil courant jusqu'à ce qu'un autre fil invoque la méthode notify() ou la méthode notifyAll() pour cet objet. En d'autres termes, cette méthode se comporte exactement comme si simplement, il effectue l'appel wait(0) .
2. le thread courant doit posséder le moniteur de cet objet. Le thread libère la propriété de ce moniteur et attend jusqu'à ce qu'un autre thread avertisse les threads qui attendent sur le moniteur de cet objet pour se réveiller
3. l'interrompt et faux réveils sont possibles
4. cette méthode ne doit être appelée que par un fil qui est le propriétaire du moniteur de cet objet

Cette méthode lève

1. IllegalMonitorStateException - si le fil courant est pas le propriétaire de l'objet du moniteur.

2. InterruptedException - si un thread a interrompu le thread courant avant ou pendant que le thread courant attendait une notification. L'état interrompu du thread courant est effacé lorsque cette exception est lancée.

De l'oracle page de documentation sur sleep() méthode de Thread classe:

public static void sleep(long millis)

1. provoque le thread en cours d'exécution à dormir (arrêt temporaire de l'exécution) pour le nombre spécifié de millisecondes, sous réserve de la précision et de la précision des minuteries et des ordonnanceurs du système.
2. le fil ne perd pas la propriété des moniteurs.

cette méthode lance:

1. IllegalArgumentException - si la valeur de millis est négative

2. InterruptedException - si un fil a interrompu le fil courant. L'état interrompu du thread courant est effacé lorsque cette exception est lancée.

autre différence clé:

wait() est une méthode non statique (méthode d'instance) contrairement à la méthode statique sleep() (méthode de classe).

• la méthode wait(1000) cause le fil courant de dormir jusqu'à une seconde .
  • un fil peut dormir moins d'une seconde s'il reçoit notify() ou notifyAll() method call.
• l'appel à sleep(1000) fait dormir le fil courant pour exactement 1 seconde .
  • Aussi thread en sommeil n'a pas de verrouillage d'une ressource quelconque . Mais thread en attente.

wait() est donné à l'intérieur d'une méthode synchronisée alors que sleep() est donné à l'intérieur d'une méthode non-synchronisée parce que wait() méthode libérer la serrure sur l'objet, mais sleep() ou yield() ne libérer le lock() .