Der Unterschied zwischen wait () und sleep ()

StackOverflow https://stackoverflow.com/questions/1036754

Frage

Was ist der Unterschied zwischen einem wait() und sleep() in Threads?

Ist mein Verständnis, dass ein wait()-ing Thema ist nach wie vor im Betriebsmodus und nutzt CPU-Zyklen, sondern ein sleep()-ing verbraucht keine CPU-Zyklen korrekt?

Warum haben wir beide wait() und sleep(): wie funktioniert ihre Implementierung auf einem niedrigeren Niveau variiert

War es hilfreich?

Lösung

A wait kann von einem anderen Thread "aufgeweckt" werden, ruft notify auf dem Monitor, der während eines sleep kann nicht. Auch ein wait (und notify) müssen in einem Block synchronized auf dem Monitor Objekt passieren während sleep nicht: 

Object mon = ...;
synchronized (mon) {
    mon.wait();
}

An diesem Punkt der aktuell ausgeführten Thread wartet und gibt den Monitor . Ein anderer Thread kann tun 

synchronized (mon) { mon.notify(); }

(auf dem gleichen mon Objekt) und dem ersten Thread (vorausgesetzt, es ist der einzige Thread ist auf dem Monitor zu warten) wird aufwachen.

Sie können auch anrufen notifyAll wenn mehr als ein Thread auf dem Monitor wartet - das wird aufwachen alle von ihnen nach oben . Doch der Lage sein, den Monitor nur eine der Threads greifen (denken Sie daran, dass die wait in einem synchronized Block) und weitermachen -. Die anderen werden dann blockiert werden, bis sie den Monitor Sperre erwerben kann

Ein weiterer Punkt ist, dass Sie rufen wait auf Object selbst (dh Sie auf ein Objekt des Monitors warten), während Sie sleep auf Thread .

Noch ein weiterer Punkt ist, dass man bekommen kann unechte Wakeups von wait (das heißt den Faden, die Lebensläufe ohne ersichtlichen Grund wartet). Sie sollten immer wait während auf einige Bedingung Spinnen wie folgt: 

synchronized {
    while (!condition) { mon.wait(); }
}

Andere Tipps

Ein wesentlicher Unterschied ist noch nicht erwähnt, dass, während ein Thema Schlafen tut nicht Arretierungen es hält, während die Sperre wartet auf das Objekt, dass wait() heißt auf. 

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


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

Ich fand diesen Beitrag hilfreich. Es stellt den Unterschied zwischen Thread.sleep(), Thread.yield() und Object.wait() in menschlicher Hinsicht. Zu zitieren:

  

Es macht alles schließlich seinen Weg nach unten an das Scheduler O, die   austeilt Zeitscheiben zu Prozessen und Threads.

     

sleep(n) sagt „Ich bin mit meinem Zeitrahmen erfüllt, und bitte mich nicht geben   ein weiterer für mindestens n Millisekunden.“ Das Betriebssystem auch dann nicht versuchen,   planen Sie den Schlaf Thread, bis die angeforderte Zeit vergangen ist.

     

yield() sagt „Ich bin mit meinem Zeitrahmen erfüllt, aber ich habe noch Arbeit   tun.“ Das Betriebssystem sofort frei ist, den Faden zu geben, eine andere Zeitscheibe,   oder einen anderen Thread zu geben oder die CPU das Nachgeben Gewinde verarbeiten   nur aufgab.

     

wait() sagt „Ich habe mit meinem Zeitrahmen erfüllt bin. Gib mir nicht ein anderer   Zeitscheibe, bis jemand anruft () benachrichtigen.“ Wie bei sleep(), das Betriebssystem wird nicht   sogar versuchen, Ihre Aufgabe zu planen, es sei denn jemand anruft notify() (oder eine   ein paar andere Wake-up-Szenarien auftreten).

     

Themen auch den Rest ihrer Zeitscheibe verlieren, wenn sie durchführen   IO und unter einigen anderen Umständen zu blockieren. Wenn ein Thread Werk   durch die gesamte Zeitscheibe nimmt das O gewaltsam Steuerung grob als   wenn yield() genannt worden ist, so dass andere Prozesse ausgeführt werden können.

     

Sie müssen selten yield(), aber wenn Sie eine rechen schwere App mit   logische Aufgabe Grenzen, ein yield() Einfügen Macht verbessern System   Ansprechbarkeit (auf Kosten der Zeit - Kontextwechsel, auch nur   um das Betriebssystem und zurück, ist nicht frei). Messen und Testen gegen Ziele, die Sie   kümmern uns um, wie immer.

Es gibt viele Antworten hier, aber ich konnte die semantische Unterscheidung auf jedem erwähnten nicht gefunden.

Es geht nicht um den Faden selbst; beide Methoden erforderlich sind, da sie sehr unterschiedliche Anwendungsfälle unterstützen.

sleep() sendet das Thema zu schlafen, wie es vorher war, ist es nur den Kontext packt und stoppt für eine vorgegebene Zeit ausgeführt wird. Also, um es zu wecken, bevor die zu gegebener Zeit auf, müssen Sie das Thema Bezug kennen. Dies ist nicht eine gemeinsame Situation in einer Multi-threaded Umgebung. Es ist vor allem für die Zeitsynchronisation (z wake in genau 3,5 Sekunden) und / oder hartcodierte Fairness (nur schlafen für eine Weile und lassen Sie andere Themen Arbeit).

wait(), im Gegenteil, ist ein Thread (oder Nachricht) Synchronisations-Mechanismus, dass Sie ein Thema zu informieren, ermöglicht, von denen Sie keine gespeicherten Referenz haben (noch Pflege). Sie können als Publish-Subscribe-Muster (wait == abonnieren und notify() == veröffentlichen) daran denken. Grundsätzlich benachrichtigen () verwenden Sie eine Nachricht senden (das könnte sogar überhaupt nicht empfangen werden und in der Regel kümmert es dich nicht).

Um es zusammenzufassen, die Sie normalerweise sleep() für zeit syncronization und wait() für Multi-Thread-Synchronisation verwendet werden.

Sie könnten auf die gleiche Weise in dem zugrunde liegenden Betriebssystem, oder gar nicht umgesetzt werden (wie in früheren Versionen von Java keine wirkliche Multithreading hatte, wahrscheinlich einige kleine VMs tun nicht, dass entweder). Vergessen Sie nicht, Java läuft auf einer VM, so dass Ihr Code wird in etwas anderes nach dem VM / O / HW transformiert wird es läuft.

Hier habe ich einige wichtige Unterschiede zwischen wait() und sleep() Methoden aufgeführt.
PS:. Auch auf die Links klicken Bibliothekscode zu sehen (interne Arbeits, um ein wenig zum besseren Verständnis nur spielen)

wait ()

  1. wait() Methode löst die Verriegelung.
  2. wait() ist die Methode der Object Klasse.
  3. wait() ist die nicht-statische Methode - public final void wait() throws InterruptedException { //...}
  4. wait() sollte durch notify() oder notifyAll() Methoden informiert werden.

  5. wait() Methode muss aus einer Schleife, um mit Fehlalarm zu behandeln genannt werden.

  6. wait() Methode muss aus Synchron Kontext (d.h. synchronisierte Methode oder Block) bezeichnet werden, sonst wird es IllegalMonitorStateException werfen

sleep ()

  1. sleep() Methode nicht die Sperre freigeben.
  2. sleep() ist die Methode der java.lang.Thread Klasse.
  3. sleep() ist die statische Methode - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
  4. nach der angegebenen Menge an Zeit, sleep() ist abgeschlossen.
  5. sleep() besser nicht von der Schleife zu nennen (d. siehe Code unten ).
  6. sleep() können von überall aufgerufen werden. gibt es keine spezielle Anforderung.

Ref: Unterschied zwischen Warten und Schlaf

Code-Snippet für Warte und Schlaf-Methode aufrufen 

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

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

thread Übergang zu unterschiedlichen Thread-Zuständen

Es gibt einige Unterschiede Keynotes i nach der Arbeit auf Warte und Schlaf schließen, zuerst einen Blick auf Probe nehmen Warte mit () und sleep ():

Example1 : mit warten () und Schlaf (): 

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

Klarheit einige wichtige Hinweise Lassen Sie:

  1. Rufen Sie auf :
    • wait (): Rufen Sie an aktuellen Thread, HandObject Object
      • halten
    • sleep (): Rufen Sie auf Thread ausführen Aufgabe Bier bekommen (ist Klassenmethode so auf laufenden Faden beeinflussen)
  2. Synchronisierte :
    • wait (): Wenn synchronisierte Multi-Thread Zugriff gleiches Objekt (HandObject) (Wenn die Kommunikation benötigt zwischen mehr als einem Thread (Thread ausgeführt Codierung, Thread ausgeführt Bier) Zugriff auf demselben Objekt HandObject erhalten)
    • sleep (): wenn die Bedingung wartet ausführen, um fortzufahren (Waiting Bier verfügbar)
  3. Halten Schloss :
    • wait (): die Sperre für anderes Objekt Chance hat, auszuführen (HandObject ist kostenlos, können Sie andere Job)
    • sleep (): Sperre hält für mindestens t mal (oder bis Interrupt) (Meine Arbeit noch nicht fertig, ich bin halte Sperre fortsetzen und eine Bedingung warten, um fortzufahren)
  4. Wake-up-Zustand :
    • wait (): bis Anruf notify (), notifyAll () von Objekt
    • sleep (): bis mindestens Zeit abläuft oder rufen Sie Interrupt
  5. Und der letzte Punkt ist Verwendung, wenn als estani zeigen:
  

Sie normalerweise sleep () für zeit syncronization verwenden und warten () für   Multi-Thread-Synchronisation.

Bitte korrigieren Sie mich, wenn ich falsch bin.

Der Unterschied zwischen wait () und sleep ()

  • Der grundlegende Unterschied besteht darin, dass aus wait() Object und sleep() ist eine statische Methode von Thread.

  • Der wesentliche Unterschied besteht darin, dass wait() die Sperre freigibt, während sleep() keine Sperre entbindet während des Wartens.

  • wait() für Inter-Thread-Kommunikation verwendet wird, während sleep() verwendet, um eine Pause bei der Ausführung einzuführen, in der Regel.

  • wait() sollte innerhalb aufgerufen werden aus synchronisieren oder sonst bekommen wir eine IllegalMonitorStateException, während sleep() überall aufgerufen werden kann.

  • Um einen Faden wieder aus wait() zu starten, haben Sie notify() oder notifyAll() nennen. Was sleep(), wird der Faden nach einem bestimmten Zeitintervall gestartet.

Similarities

  • machen Sowohl der aktuelle Thread geht in den Nicht Runnable Zustand.
  • Beide sind nativer Methoden.

Dies ist eine sehr einfache Frage, weil diese beiden Methoden eine ganz andere Verwendung haben.

Der große Unterschied ist, zu warten, um die Verriegelung zu lösen oder zu überwachen, während Schlaf keine Sperre entbindet oder Monitor während der Wartezeit. Warten für inter-thread-Kommunikation verwendet wird, während Schlaf verwendet wird Pause bei der Ausführung einzuführen.

Dies war nur eine klare und einfache Erklärung, wenn Sie mehr wollen als das, dann lesen Sie weiter.

Bei wait() Methode Thread geht in Wartezustand und es wird nicht wieder automatisch, bis wir die notify() Methode aufrufen (oder notifyAll(), wenn Sie mehr als einen Thread im Wartebetrieb und Sie wollen all die Thread wecken) . Und Sie müssen synchronisiert oder Objektsperre oder Klassensperre die wait() oder notify() oder notifyAll() Methoden zuzugreifen. Und noch eine Sache, die wait() Methode für inter-thread Kommunikation verwendet wird, weil, wenn ein Thread sich in Wartestellung geht Sie einen anderen Thread brauchen diesen Thread zu wecken.

Aber im Falle von sleep() ist dies ein Verfahren, das den Prozess für einige Sekunden oder die Zeit, die Sie wollte halten verwendet wird. Weil Sie müssen jede notify() oder notifyAll() Methode nicht provozieren, um diesen Thread zurück. Oder Sie brauchen keinen anderen Thread, Thread rufen Sie zurück. Wie, wenn Sie etwas wollen, nach wenigen Sekunden wie in einem Spiel nach Benutzer an der Reihe passieren soll, möchten Sie die Benutzer warten, bis der Computer spielt dann können Sie die sleep() Methode nennen.

Und noch ein wichtiger Unterschied, der in Interviews oft gefragt wird: sleep() gehört zur Klasse und Thread wait() gehören zur Klasse Object

.

Das sind die Unterschiede zwischen sleep() und wait().

Und es gibt eine Ähnlichkeit zwischen den beiden Methoden. Sie beide Anweisung überprüft werden, so dass Sie fangen versuchen müssen oder wirft, um diese Methoden zugreifen

Ich hoffe, dies wird Ihnen helfen.

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

  

Thread.sleep() sendet den aktuellen Thread in den "Nicht Runnable" Zustand   für gewisse Zeit. Das Gewinde hält die überwacht es aquired hat   - das heißt, wenn der Faden wird derzeit in einem synchronisierten Block oder das Verfahren kein anderer Thread kann diesen Block oder Verfahren ein. Wenn ein anderer Thread ruft t.interrupt() es wird der Schlaf Thread aufwachen.

     

Beachten Sie, dass Schlaf eine statische Methode ist, was bedeutet, dass es immer beeinflusst   der aktuelle Thread (die, die in den Schlaf Verfahren ausführen). EIN   häufiger Fehler ist t.sleep() zu nennen, wo t ein anderer Thread ist;   selbst dann, es ist der aktuelle Thread, schläft, nicht der t-Thread.

     

t.suspend() ist veraltet. Mit ihm ist möglich, einen anderen Thread zu beenden   als der aktuelle Thread. Ein Thread suspendiert hält all seinen Monitoren und   da dieser Zustand nicht unterbrechbare ist es anfällig ist Deadlock.

     

object.wait() sendet den aktuellen Thread in den "Nicht Runnable" Zustand,   wie sleep(), aber mit einem Twist. Warten auf einem Objekt aufgerufen, keine   Faden; wir nennen das Objekt des „Sperrobjekt.“ Vor lock.wait() ist   genannt wird, muß der aktuelle Thread auf dem Sperrobjekt synchronisieren; wait()   gibt dann diese Sperre, und fügt den Faden auf die „Warteliste“   mit dem Schloß verbunden. Später kann ein anderer Thread auf die Synchronisierungs   gleiches Sperrobjekt und Call lock.notify(). Dies weckt die Original-up,   Warte Faden. Grundsätzlich wait() / notify() ist wie   sleep() / interrupt(), nur der aktive Thread braucht keinen direkten   Zeiger auf den schlafenden Thread, aber nur in dem gemeinsam genutzten Verriegelungsobjekt.

Warten und Schlaf sind zwei verschiedene Dinge:

  • In sleep() der Faden hält für die angegebene Dauer zu arbeiten.
  • In wait() der Faden nicht mehr funktioniert, bis das Objekt gewartet-on wurde benachrichtigt wird, in der Regel von anderen Threads.

sleep Verfahren zum Thread ist, wait ist ein Verfahren der Object, so wait/notify ist eine Technik des gemeinsam benutzte Daten in Java Synchronisieren (mit Monitor ), aber sleep ein einfaches Verfahren zum Faden selbst zu unterbrechen.

sleep () ist ein Verfahren, das den Prozess für einige Sekunden oder die Zeit, die Sie aber im Fall der Methode wait () Thread wollten halten verwendet wird, gehen in Wartezustand und es wird nicht kommen automatisch zurück, bis wir die notify () oder notifyAll () aufrufen.

Der Hauptunterschied ist, dass wait () gibt die Sperre oder überwachen, während sleep () keine Meldungen jede Sperre oder Monitor während der Wartezeit. Warten Sie werden verwendet, um inter-thread-Kommunikation während Schlaf verwendet wird Pause bei der Ausführung einzuführen, in der Regel.

Thread.sleep () sendet den aktuellen Thread in den „Nicht Runnable“ Zustand für eine bestimmte Zeitdauer. Das Gewinde hält die überwacht er erworben hat - das heißt, wenn der Thread zur Zeit in einem synchronisierten Block oder Methode ist kein anderer Thread diesen Block oder Methode eingeben. Wenn ein anderer Thread ruft t.interrupt () wird es den Schlaf Thread aufwachen. Man beachte, dass der Schlaf ist ein statisches Verfahren, was bedeutet, dass sie immer den aktuellen Thread betrifft (die eine, die die Schlaf-Methode ausgeführt wird). Ein häufiger Fehler ist t.sleep () aufzurufen, wobei t einem anderen Thread ist; selbst dann, es ist der aktuelle Thread, schläft, nicht der t-Thread.

Object.wait () sendet den aktuellen Thread in den „Nicht Runnable“ Zustand, wie Schlaf (), aber mit einem Twist. Warten auf einem Objekt aufgerufen, keinen Faden; Wir nennen dieses Objekt des „Sperrobjekt“. Bevor lock.wait () aufgerufen wird, der aktuelle Thread auf dem Sperrobjekt synchronisieren muß; wait () gibt dann diese Sperre, und fügt den Faden nach dem die Sperre zugeordnet „Warteliste“. Später kann ein anderer Thread auf dem gleichen Sperrobjekt synchronisieren und rufen lock.notify (). Dies weckt das Original, wartet Faden wieder auf. Grundsätzlich wait () / notify () ist wie Schlaf () / unterbrechen (), werden nur der aktive Thread keinen direkten Pointer auf das Schlaf Gewinde benötigt, sondern nur auf das freigegebene Sperrobjekt. 

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

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

Lassen Sie alle oben genannten Punkte kategorisieren:

Call on:

  • wait (): Rufen Sie an einem Objekt; aktuelle Thread auf dem Sperrobjekt synchronisieren muß.
  • sleep (): Rufen Sie auf einem Thema; immer zur Zeit Thread ausgeführt wird.

Synchronized:

  • wait ():. , wenn mehrere Threads zugreifen gleichen Objekt nacheinander synchronisiert
  • sleep (.): , wenn mehrere Threads synchronisiert warten Schlaf über Gewinde des Schlafens

Hold lock:

  • wait ():. die Sperre für andere Objekte Chance zu haben, auszuführen
  • sleep ():. halte Sperre für mindestens t mal wenn Timeout angegeben oder jemand unterbrechen

Wake-up condition:

  • wait (): , bis der Anruf notify (), notifyAll () von Objekt
  • sleep ():. , bis zumindest die Zeit ungültig oder rufen Sie Interrupt ()

Usage:

  • sleep (): für Zeitsynchronisation und;
  • wait (): für Multi-Thread-Synchronisation
    • .

Ref: diff sleep und wait

wait und sleep Methoden sind sehr unterschiedlich:

  • sleep hat keine Möglichkeit, „Aufwecken“,
  • wait hat eine Art „Aufwecken“ während der Wartezeit von einem anderen Thread aufrufen notify oder notifyAll .

Kommen Sie darüber nachdenken, werden die Namen in dieser Hinsicht sind verwirrend; jedoch sleep ist ein Standardname und wait ist wie die WaitForSingleObject oder WaitForMultipleObjects in dem Win-API.

In einfachen Worten, Warten warten, bis ein anderer Thread Sie ruft während des Schlafes „nicht nächste Anweisung ausführen“ für einige bestimmten Zeitraum.

Außerdem Schlaf statische Methode in Thread-Klasse und arbeitet auf Faden, während wait () in Objektklasse ist und auf einem Objekt bezeichnet wird.

Ein weiterer Punkt, wenn Sie warten auf einen Gegenstand nennen, beteiligt der Thread synchronisieren Sie das Objekt und dann wartet. :)

Von diesem Beitrag: http://javaconceptoftheday.com / Differenz zwischen-wait-and-Schlaf-Methoden-in-java /

wait () Methode.

1) Der Faden, die Wartezeit ruft () Methode gibt die Sperre sie hält.

2) Der Faden gewinnt die Sperre nach dem anderen Threads rufen entweder benachrichtigen () oder notifyAll () Verfahren auf der gleichen Sperre.

3) Warten () Methode muss innerhalb des synchronisierten Block bezeichnet werden.

4) warten () -Methode immer auf Objekte aufgerufen wird.

5) Wartefäden können durch andere Threads aufgeweckt werden durch benachrichtigen () aufrufen oder notifyAll () Methoden.

6), wait () Methode aufzurufen, müssen Thread Objektsperre haben.

sleep () Methode

1) Der Faden, der sleep () Methode aufruft lüftet nicht das Schloss es hält.

2) sleep () Methode kann innerhalb oder außerhalb des synchronisierten Block bezeichnet werden.

3) sleep () Methode immer auf Threads aufgerufen wird.

4) Sleeping Threads kann nicht von anderen Threads aufgeweckt werden. Wenn dies getan, Thread InterruptedException werfen.

5) zu nennen, sleep () Methode, Faden braucht nicht Objektsperre zu haben.

  1. wait() ist eine Methode der Object Klasse.
    sleep() ist eine Methode der Thread Klasse.

  2. sleep() erlaubt es dem Thread zu gehen Zustand für x Millisekunden sleep.
    Wenn ein Thread geht in den Schlafzustand it doesn’t release the lock.

  3. wait() erlaubt Thread die Sperre und goes to suspended state zu lösen.
    Dieser Thread ist aktiv, wenn eine oder notify() notifAll() Methode ist genannt für das gleiche Objekt.

Ein möglicher großer Unterschied zwischen Schlaf / unterbrechen und warten / benachrichtigen ist, dass

eine Ausnahme zu erzeugen, wenn nicht ineffizient erforderlich ist. Wenn Sie Threads mit einer hohen Rate, die miteinander kommunizieren, dann wäre es eine Menge Ausnahmen zu erzeugen, wenn Sie Interrupt ganze Zeit fordert, die eine völlige Verschwendung von CPU ist.

Sie sind richtig - Sleep () führt dazu, dass Thread andere Threads zu „Schlaf“ und die CPU erlischt und Prozess (auch als Kontextwechsel bekannt) wheras Ich glaube, warten, bis die CPU die Verarbeitung des aktuellen Thread hält

.

Wir haben beide denn obwohl es sinnvoll erscheint, können andere Leute die CPU verwenden zu lassen, während Sie es nicht verwenden, actualy ein Overhead Zusammenhang gibt es Schalt - je nachdem, wie lange der Schlaf ist für, kann es teurer sein in CPU-Zyklen, Threads zu wechseln, als es einfach ist beschränkt auf deinen Thread nichts für ein paar ms tun.

Beachten Sie auch, dass der Schlaf ein Kontextschalter drückt.

Auch - in der Regel ist es nicht möglich, Kontextwechsel zu steuern - während die das Betriebssystem warten kann (und wird für längere Wartezeiten) wählt andere Threads zu verarbeiten

.

Die verwendeten Methoden sind für verschiedene Dinge. 

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

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

Thread.sleep (n) können unterbrochen werden, aber Object.wait () muss benachrichtigt. Es ist möglich, die maximale Zeit angeben, zu warten. Object.wait(5000) so wäre es möglich, wait zu, äh, sleep zu verwenden, aber dann muss man mit Schlössern stören

Keine der Methoden verwendet die CPU während des Schlafes / warten.

Die Methoden sind implementiert nativen Code, ähnliche Konstrukte verwenden, aber nicht in der gleichen Art und Weise.

Sehen Sie selbst: Ist der Quellcode von nativen Methoden zur Verfügung? die Datei /src/share/vm/prims/jvm.cpp ist der Ausgangspunkt ...

Hier wait () im Wartezustand sein wird, bis es von einem anderen Thread mitteilen, aber wo, wie sleep () wird einige time..after werden muss, dass es in den Bereitschaftszustand automatisch übertragen wird ...

Wait () und sleep () Unterschiede?

Thread.sleep ()      Nach Abschluss der Arbeit seiner Veröffentlichung dann nur die Sperre für alle. bis seine nie die Sperre für jedes freigeben. 

  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.

Object.wait ()     Wenn sein zu warten Bühne geht, wird sie den Schlüssel und seine Warte für einige der auf der Grundlage des Parameter Sekunden lösen sein.

Beispiel:

Sie nehmen sind die Kaffee in deiner rechten Hand, können Sie ein anderes jemand von der gleichen Hand nehmen, wenn Sie Ihre setzen wird dann nur ein anderes Objekt gleichen Typs hier. ebenfalls. dies ist sleep ()  Sie schlafen Zeit, die Sie keine Arbeit haben, tun Sie nur schlafen .. hier gilt das gleiche auch.

wait (). wenn Sie setzen nach unten und nehmen Sie ein anderes bedeuten, während Sie warten, das ist warten

Sie spielt Film oder irgendetwas in Ihrem System gleich wie Spieler sind Sie nicht mehr als ein zu einer Zeit richtig spielen können, das sind seine hier, wenn Sie in der Nähe und wählen Sie ein anderes jemand Film oder Song bedeuten, während genannte Wartezeit wird

wait die Sperre und sleep nicht. Ein Thread sich in Wartestellung ist, die für das Aufwachen, sobald notify oder notifyAll genannt wird. Aber im Fall von sleep des Faden hält das Schloss und es wird nur dann förderfähig, wenn die Ruhezeit ist vorbei.

sleep() Verfahren bewirkt, dass der aktuellen Thread vom Fahrzustand zu bewegen Zustand für eine bestimmte Zeit zu blockieren. Wenn der aktuelle Thread die Sperre eines Objekts hat dann hält sie es hält, was bedeutet, dass eine beliebige andere Threads synchronisiert Verfahren in dieser Klasse Objekt nicht ausführen kann.

wait() Verfahren bewirkt, dass der aktuellen Thread in Blockzustand gehen, entweder für eine bestimmte Zeit oder bis benachrichtigen, aber in diesem Fall gibt den Thread die Sperre des Objekts (was bedeutet, dass andere Threads keine synchronisierten Methoden des anrufenden Objekts ausführen können .

Meiner Meinung nach ist der Hauptunterschied zwischen den beiden Mechanismen ist, dass der Schlaf / Interrupt wird die grundlegendste Art und Weise Fäden der Handhabung, während warten / notify ist eine Abstraktion Ziel zu erleichtern die gegenseitige Kommunikation zu tun fädeln. Dies bedeutet, dass der Schlaf / Interrupt alles tun kann, sondern dass diese spezifische Aufgabe schwieriger ist, zu tun.

Warum warten / notify besser geeignet? Hier sind einige persönliche Überlegungen:

  1. Es erzwingt Zentralisierung. Es ermöglicht die Kommunikation zwischen einer Gruppe von Fäden mit einem einzelnen gemeinsamen Objekt zu koordinieren. Dies erleichtert die Arbeit sehr.

  2. Es erzwingt die Synchronisation. Weil es der Programmierer macht den Anruf wickelt in einem synchronisierten Block zu warten / benachrichtigen.

  3. Es ist unabhängig von der Faden Herkunft und Zahl. Mit diesem Ansatz können Sie mehr Threads beliebig hinzugefügt werden, ohne die anderen Threads zu bearbeiten oder eine Übersicht über die bestehenden zu halten. Wenn Sie schlafen verwendet / unterbrechen, zuerst würden Sie die Verweise auf die Schlaf Fäden halten müssen, und ihnen dann eine Unterbrechung durch einen, von Hand.

Ein Beispiel aus dem wirklichen Leben, das gut ist zu erklären, das ein klassisches Restaurant ist und die Methode, die das Personal unter ihnen zu kommunizieren: Die Kellner die Kundenwunsch in einem zentralen Ort zu verlassen (eine Kork-Board, ein Tisch, etc eine Glocke, und die Arbeiter aus der Küche.), kommen klingelt solche Anfragen zu nehmen. Einmal, dass jeder Kurs fertig ist, läutet das Küchenpersonal die Glocke wieder, so dass die Kellner bewusst sind, und nehmen sie an den Kunden.

Beispiel über den Schlaf entbindet nicht Sperre und warten tut

Hier gibt es zwei Klassen:

  1. Haupt :. Enthält Hauptmethode und zwei Threads

  2. Singleton . Dies ist Singletonklasse mit zwei statischen Methoden getInstance () und 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();

 }
}

und 

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;

 }
}

Jetzt dieses Beispiel auszuführen Sie unter Ausgabe: 

_instance :null
Both singleton are same

Hier Singleton-Instanzen erstellt von ThreadA und ThreadB sind gleich. Es bedeutet ThreadB außerhalb bis ThreadA Release wartet es zu sperren.

Sie nun die Singleton.java ändern, indem Kommentierung Thread.sleep (500); Verfahren und Auskommentierung Singleton.class.wait (500); . Hier wegen Singleton.class.wait (500); Verfahren ThreadA wird lösen alle Schlösser und bewegt sich in den „Non Runnable“ Zustand zu erwerben, wird ThreadB erhalten ändern in synchronisierten Block eingeben.

Jetzt läuft wieder: 

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

Hier Singleton Instanzen von ThreadA und ThreadB erstellt wird, sind nicht gleich, weil der ThreadB ändern konnte in synchronisierten Block und nach 500 Millisekunden eingeben ThreadA begann aus der letzten Position ist und erstellt ein weiteres Singleton-Objekt.

Sollte aus synchronisierten Block aufgerufen werden: wait() Methode aufgerufen wird immer von synchronisierten Block heißen wait() Methode muss Objekt Monitor sperrt, bevor Objekt, auf das sie aufgerufen wird. Aber sleep() Methode kann von außen synchronisierten Block heißt sleep() Methode aufgerufen wird keinen Objekt-Monitor benötigen.

IllegalMonitorStateException:. , wenn wait() Verfahren ohne den Erwerb Objektsperre als IllegalMonitorStateException aufgerufen wird, wird zur Laufzeit geworfen, aber sleep() Methode löst nie eine solche Ausnahme

gehört zu der Klasse. wait() Methode gehört zur Klasse aber java.lang.Object Methode sleep() gehört zur Klasse java.lang.Thread

aufgerufen, auf dem Objekt oder Thread:. wait() Methode auf Objekte aufgerufen wird aber sleep() Methode basiert auf Threads nicht Objekte genannt

Themen-Zustand: , wenn wait() Methode auf dem Objekt aufgerufen wird, Thread, holded Objekts Monitor Zustand vom Laufen zu warten, geht und kann auf runnable Zustand zurück, nur wenn notify() oder notifyAll() Methode für das Objekt aufgerufen wird. Und später Thread-Scheduler Zeitplan, der Thread zu gehen aus von runnable zu Zustand ausgeführt wird. wenn sleep() auf Thread aufgerufen wird, geht es vom Laufen auf Wartezustand und zu runnable Zustand zurückkehren kann, wenn der Schlaf Zeit abgelaufen ist.

Wenn aus Synchronblock genannt: , wenn wait() Verfahren Thread aufgerufen wird, verlässt die Objektsperre. Aber sleep() Methode, wenn sie von synchronisierten Block oder eine Methode Thread aufgerufen nicht Blätter Sperrobjekt.

Mehr Referenz

Von der Oracle-Dokumentation Seite auf warten () Methode Object: 

public final void wait()
  1. Bewirkt, dass der aktuelle Thread warten, bis ein anderer Thread die notify()-Methode oder die notifyAll() Methode für dieses Objekt aufruft. Mit anderen Worten verhält sich diese Methode genau, als ob es den Anruf einfach wait(0) führt.
  2. Der aktuelle Thread muss dieses Objekt Monitor besitzen. Der Thread Meldungen Eigentum an diesen Monitor und wartet, bis ein anderer Thread benachrichtigt Threads zu diesem Objekt Monitor wartet aufwachen
  3. Interrupts und unechte Wakeups sind möglich
  4. Diese Methode sollte nur von einem Thread aufgerufen werden, der Besitzer dieses Objekts Monitor

Dieses Verfahren wirft

  1. IllegalMonitorStateException -., Wenn der aktuelle Thread Monitor nicht der Eigentümer des Objekts

  2. InterruptedException - wenn ein Thread den aktuellen Thread vor oder während der aktuelle Thread unterbrochen wurde für eine Benachrichtigung warten. Der unterbrochene Zustand des aktuellen Threads gelöscht, wenn diese Ausnahme ausgelöst wird.

Von der Oracle-Dokumentation Seite auf sleep () Methode der Thread Klasse: 

public static void sleep(long millis)
  1. Ursachen der aktuell ausgeführten Thread (vorübergehend aufhören Ausführung) für die angegebene Anzahl von Millisekunden zu schlafen, vorbehaltlich der Präzision und Genauigkeit der System-Timer und Disponenten.
  2. Der Faden nicht das Eigentum an allen Monitoren verlieren.

Diese Methode führt:

  1. IllegalArgumentException - wenn der Wert von Millis negativ

  2. InterruptedException - wenn ein Thread den aktuellen Thread unterbrochen hat. Der unterbrochene Zustand des aktuellen Threads gelöscht, wenn diese Ausnahme ausgelöst wird.

Weiterer wichtiger Unterschied:

wait() ist eine nicht statische Methode (instance Verfahren) Im Gegensatz zu statischen Verfahren sleep() (class-Verfahren).

wait() ist innerhalb eines synchronisierten Verfahren gegeben während sleep() ist in einem nicht synchronisierten Verfahren gegeben, weil wait() Methode für das Objekt das Schloss freizugeben, aber sleep() oder yield() die lock() entbindet.

mit einem Timeout-Wert wartet auf Timeout-Wert verstrichene Wakeup oder benachrichtigen je nachdem was früher ist (oder auch unterbrechen), während ein Schlaf auf Timeout-Wert aufwacht verstrichen oder Interrupt je nachdem, was früher eintritt. wait () ohne Timeout-Wert wird für immer warten, bis benachrichtigt oder unterbrochen

scroll top