Różnica między wait () a sleep()

Kluczową różnicą, o której jeszcze nie wspomniano, jest to, że podczas snu wątek nie zwalnia blokad, które posiada, podczas oczekiwania zwalnia blokadę obiektu, który jest wywoływany.

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


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

Znalazłem ten link pomocny (który odwołuje się ten post). Stawia różnicę między sleep(), wait(), i yield() w kategoriach ludzkich. (W przypadku, gdy linki kiedykolwiek znikną, dodałem poniższy post z dodatkowymi znacznikami)

To wszystko ostatecznie trafia do schedulera OS, który rozdaje timeslices do procesów i wątków.

sleep(n) says "mam dość czasu i proszę, nie dawaj mi inny jeden przez co najmniej n milisekund." OS nawet nie próbuje zaplanuj wątek uśpienia do czasu upłynięcia żądanego czasu.

yield() says "mam dość czasu, ale mam jeszcze pracę do zrób." OS może od razu dać wątek innym razem, lub dać jakiś inny wątek lub przetworzyć procesor wątek poddałem się.

.wait() says "mam dość czasu. Don ' t give me another czas, aż ktoś wywoła notify ()." podobnie jak w przypadku sleep(), OS nie będzie nawet spróbuj zaplanować swoje zadanie, chyba że ktoś zadzwoni notify() (lub jeden z występuje kilka innych scenariuszy przebudzenia).

Wątki tracą także resztę czasu, gdy wykonują blokowanie IO i w kilku innych okolicznościach. Jeśli wątek działa przez cały czas, System operacyjny siłą przejmuje kontrolę mniej więcej tak, jak jeśli yield() zostało wywołane, aby inne procesy mogły działać.

Rzadko potrzebujesz yield(), ale jeśli masz aplikację o dużej mocy obliczeniowej z logiczne granice zadań, wstawianie yield() może poprawić system responsywność (kosztem przełączników czasu-kontekstu, nawet tylko do systemu operacyjnego i z powrotem, nie są wolne). Mierz i testuj przed celami dbać o, jak zawsze.

Jest tu wiele odpowiedzi, ale nie mogłem znaleźć rozróżnienia semantycznego wymienionego na żadnym.

Nie chodzi o sam wątek; obie metody są wymagane, ponieważ obsługują bardzo różne przypadki użycia.

sleep() wysyła wątek w stan uśpienia, jak to było wcześniej, po prostu pakuje kontekst i przestaje wykonywać na predefiniowany czas. Aby go obudzić przed odpowiednim czasem, musisz znać odniesienie do wątku. Nie jest to powszechna sytuacja w środowisku wielowątkowym. Jest używany głównie do synchronizacji czasu (np. budzenie W dokładnie 3,5 sekundy) i/lub hard-coded uczciwości (wystarczy spać przez chwilę i niech inni wątki pracy).

wait(), wręcz przeciwnie, jest mechanizm synchronizacji wątku (lub wiadomości), który pozwala powiadomić wątek, w którym nie ma przechowywanego odniesienia (ani opieki). Możesz myśleć o tym jako o wzorcu publikuj-Subskrybuj (wait == subskrybuj i notify() == publikuj). Zasadniczo używając notify() wysyłasz wiadomość (która może nawet nie być otrzymany w ogóle i normalnie ci to nie przeszkadza).

Podsumowując, zwykle używasz sleep() do synchronizacji czasu i wait() do synchronizacji wielu wątków.

Mogą być zaimplementowane w ten sam sposób w systemie operacyjnym, lub wcale (ponieważ poprzednie wersje Javy nie miały prawdziwej wielowątkowości; prawdopodobnie niektóre małe maszyny wirtualne też tego nie robią). Nie zapomnij, że Java działa na maszynie wirtualnej, więc Twój kod zostanie przekształcony w coś innego w zależności od maszyny Wirtualnej/systemu operacyjnego/sprzętu, na którym działa.

Tutaj wymieniłem kilka istotnych różnic między metodami wait() i sleep().
PS: kliknij również na linki, aby zobaczyć kod biblioteki(wewnętrzny działa, po prostu pobaw się trochę dla lepszego zrozumienia).

Czekaj.()

1. wait() metoda zwalnia blokadę.
2. wait() jest metodą klasy Object.
3. wait() jest metodą niestatyczną - public final void wait() throws InterruptedException { //...}
4. wait() powinny być zgłoszone przez notify() lub notifyAll() metody.

5. wait() Metoda musi być wywołana z pętli, aby poradzić sobie z fałszywym alarmem.

6. wait() Metoda musi być wywołana z zsynchronizowanego kontekstu( tzn. zsynchronizowana metoda lub blok), w przeciwnym razie rzuci IllegalMonitorStateException

Sen()

1. sleep() metoda nie zwalnia blokady.
2. sleep() jest metodą klasy java.lang.Thread.
3. sleep() jest metodą statyczną- public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. po określonej ilości czasu, sleep() jest zakończona.
5. sleep() lepiej nie wywoływać z pętli(np. patrz kod poniżej ).
6. Może być wywoływany z dowolnego miejsca. nie ma szczególnych wymagań.

Ref: różnica między czekaniem a snem

Fragment kodu do wywołania metody wait I sleep

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

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

Są pewne różnice, które stwierdzam po pracy nad wait I sleep, najpierw spójrz na próbkę za pomocą wait () I sleep ():

Przykład1: użycie wait() i sleep():

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

Let clarity some key notes:

1. Call on :
   • wait (): wywołanie bieżącego wątku trzymającego obiekt HandObject
   • sleep (): Call on Thread execute task get beer (is class method so affect on current running wątek)
2. zsynchronizowane :
   • wait (): gdy zsynchronizowany dostęp do wielu wątków tego samego obiektu (HandObject) (gdy potrzeba komunikacji między więcej niż jednym wątkiem (thread execute coding, thread execute get beer) dostęp do tego samego obiektu HandObject )
   • sleep (): gdy stan oczekiwania ma być kontynuowany (dostępne piwo oczekujące)
3. Hold lock :
   • wait (): zwolnij blokadę dla innego obiektu, który ma szansę wykonać (HandObject jest darmowy, możesz wykonywać inne zadania)
   • sleep (): utrzymuj blokadę przez co najmniej t razy (lub do przerwania) (Moja praca nadal nie kończy się, kontynuuję przytrzymaj blokadę i czekam na jakiś warunek, aby kontynuować)
4. Stan przebudzenia :
   • wait (): until call notify (), notifyAll () from object
   • sleep (): do co najmniej czasu wygaśnięcia lub przerwania wywołania
5. i ostatni punkt to Użyj gdy jako estani wskazać:

Zwykle używasz funkcji sleep () do synchronizacji czasu i wait () do synchronizacja wielowątkowa.

Różnica między wait () a sleep ()

• Podstawową różnicą jest to, że {[0] } jest z Object i sleep() jest statyczna Metoda Thread.

• Główną różnicą jest to, że wait() zwalnia blokadę, podczas gdy sleep() nie zwalnia żadnej blokady podczas oczekiwania.

• wait() jest używany do komunikacji między wątkami, podczas gdy sleep() jest używany do wprowadzenia pauzy podczas wykonywania, ogólnie.

• wait() powinien dzwonić od wewnątrz zsynchronizuj się albo otrzymamy IllegalMonitorStateException, podczas gdy {[2] } możemy wywołać w dowolnym miejscu.

• aby ponownie uruchomić wątek z wait(), musisz zadzwonić notify() lub notifyAll(). While in sleep(), thread zaczyna się po określonym interwale ms / sec.

Podobieństwa, które pomagają zrozumieć

• oba powoduje, że bieżący wątek przechodzi do stanu nie można uruchomić .
• obie są native metodami.

Jest to bardzo proste pytanie, ponieważ obie te metody mają zupełnie inne zastosowanie.

Główną różnicą jest czekanie na zwolnienie blokady lub monitora, podczas gdy sen nie zwalnia żadnej blokady lub monitora podczas oczekiwania. Wait jest używany do komunikacji między wątkami, podczas gdy sleep jest używany do wprowadzenia pauzy podczas wykonywania.

To było tylko jasne i podstawowe Wyjaśnienie, jeśli chcesz więcej niż to, to czytaj dalej.

W przypadku wait() wątku metody przechodzi w stan oczekiwania i nie wróci automatycznie, dopóki nie wywołamy metody notify() (lub notifyAll() Jeśli masz więcej niż jeden wątek w stanie oczekiwania i chcesz obudzić wszystkie wątki). Aby uzyskać dostęp do metod wait() LUB notify() lub notifyAll(), potrzebujesz synchronized lub object lock lub class lock. I jeszcze jedno, metoda wait() jest używana do komunikacji między wątkami, ponieważ jeśli wątek przechodzi w stan oczekiwania, będziesz potrzebował innego wątku, aby go obudzić.

Ale w przypadku sleep() jest to metoda, która jest używana do przytrzymania procesu przez kilka sekund lub czas, który chciałeś. Ponieważ nie musisz prowokować żadnej metody notify() lub notifyAll(), aby odzyskać ten wątek. Albo nie potrzebujesz żadnego innego wątku, aby oddzwonić do tego wątku. Jeśli chcesz, aby coś się stało po kilku sekundach, jak w grze po kolejkach użytkownika chcesz, aby użytkownik poczekał, aż komputer zagra, możesz wspomnieć o metodzie sleep().

I jeszcze jedna ważna różnica, o którą często się pyta w wywiady: sleep() należy do klasy Thread i wait() należy do klasy Object.

To wszystkie różnice pomiędzy sleep() i wait().

I istnieje podobieństwo między obiema metodami: obie są instrukcją checked, więc musisz spróbować catch lub throws, aby uzyskać dostęp do tych metod.

Źródło: http://www.jguru.com/faq/view.jsp?EID=47127

Thread.sleep() wysyła bieżący wątek do stanu "Not Runnable" przez jakiś czas. Wątek utrzymuje monitory, które nabył -- tzn. jeżeli wątek jest aktualnie w zsynchronizowanym bloku lub metodzie żaden inny wątek nie może wprowadzić tego bloku lub metody. Jeśli inny wątek wywoła t.interrupt() obudzi śpiącą nić.

Zauważ, że sen jest statycznym metoda, co oznacza, że zawsze wpływa bieżący wątek (ten, który wykonuje metodę sleep). A częstym błędem jest wywołanie t.sleep() Gdzie t jest innym wątkiem; nawet wtedy to bieżący wątek będzie spać, a nie wątek T.

t.suspend() jest przestarzały. Za jego pomocą można zatrzymać wątek inny niż obecny wątek. Zawieszony gwint utrzymuje wszystkie monitory i ponieważ stan ten nie jest przerywalny, jest podatny na impas.

object.wait() wysyła bieżący wątek do stanu "Not Runnable" , jak sleep(), ale z akcentem. Wait jest wywoływany na obiekcie, a nie na thread; obiekt ten nazywamy "lock object."Przed lock.wait() jest wywołany, bieżący wątek musi zsynchronizować się na obiekcie lock; wait() następnie zwalnia tę blokadę i dodaje wątek do " listy oczekujących" związane z zamkiem. Później inny wątek może zsynchronizować się na ten sam obiekt blokady i wywołanie lock.notify(). To budzi oryginał, wątek oczekujący. Zasadniczo, wait()/notify() jest jak sleep()/interrupt(), tylko aktywny wątek nie wymaga bezpośredniego wskaźnik do uśpionego wątku, ale tylko do współdzielonego obiektu blokady.

Czekać i spać to dwie różne rzeczy:

• W sleep() Wątek przestaje działać na określony czas.
• W wait() Wątek przestaje działać, dopóki obiekt, na który czekał, nie zostanie powiadomiony, zazwyczaj przez inne wątki.

sleep jest metodą Thread, wait jest metodą Object, więc wait/notify jest techniką synchronizacji współdzielonych danych w Javie (za pomocą monitor), Ale sleep jest prostą metodą wątku do wstrzymania się.

Sleep () jest metodą, która jest używana do przytrzymania procesu przez kilka sekund lub czas, który chciałeś, ale w przypadku wait () wątek metody przechodzi w stan oczekiwania i nie wróci automatycznie, dopóki nie wywołamy notify () lub notifyAll ().

Główna różnica polega na tym, że wait() zwalnia blokadę lub monitor, gdy funkcja sleep() nie zwalnia żadnej blokady lub monitora podczas oczekiwania. Wait jest używany do komunikacji między wątkami, podczas gdy sleep jest używany do wprowadzania pauzy na egzekucję, ogólnie.

Nić.sleep () wysyła bieżący wątek do stanu "Not Runnable" przez pewien czas. Wątek zachowuje monitory, które nabył - tzn. jeśli wątek jest obecnie w zsynchronizowanym bloku lub metodzie, żaden inny wątek nie może wprowadzić tego bloku lub metody. Jeśli inny wątek wywoła t. interrupt (), obudzi śpiący wątek. Zauważ, że sleep jest metodą statyczną, co oznacza, że zawsze wpływa na bieżący wątek (ten, który jest wykonywany metoda snu). Częstym błędem jest wywołanie t. sleep (), gdzie t jest innym wątkiem; nawet wtedy to bieżący wątek będzie spał, a nie wątek t.

Obiekt.wait () wysyła bieżący wątek do stanu "nie do uruchomienia", jak sleep (), ale z przekrętem. Wait jest wywoływany na obiekcie, a nie wątku; obiekt ten nazywamy "lock object."Przed zamkiem.wait () jest wywoływana, bieżący wątek musi zsynchronizować się z obiektem lock; wait () zwalnia tę blokadę i dodaje wątek do" listy oczekujących " związanej z blokadą. Później inny wątek może zsynchronizować się na tym samym obiekcie lock I call lock.notify (). To budzi oryginalny, oczekujący wątek. Zasadniczo wait () / notify () jest jak sleep () / interrupt (), tylko aktywny wątek nie potrzebuje bezpośredniego wskaźnika do uśpionego wątku, ale tylko do współdzielonego obiektu blokady.

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

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

Podzielmy wszystkie powyższe punkty:

Call on:

• wait (): wywołanie obiektu; bieżący wątek musi zsynchronizować się z obiektem blokady.
• sleep (): wywołanie wątku; zawsze aktualnie wykonujący wątek.

Synchronized:

• wait (): gdy zsynchronizowane wiele wątków uzyskuje dostęp do tego samego obiektu jeden po drugim.
• sleep (): gdy zsynchronizowane wiele wątków czeka na sen nad uśpionym wątkiem.

Hold lock:

• wait (): zwolnij blokadę, aby inne obiekty miały szansę wykonać.
• sleep (): zachowaj blokadę przez co najmniej t razy, jeśli określony jest timeout lub ktoś przerwał.

Wake-up condition:

• wait (): until call notify (), notifyAll () from object
• sleep (): do co najmniej czasu expire lub wywołania interrupt ().

Usage:

• sleep (): do synchronizacji czasu i;
• wait (): for synchronizacja wielowątkowa.

Ref: diff sleep i wait

wait i sleep Metody są bardzo różne:

• sleep nie ma możliwości "przebudzenia się",
• wait mA sposób "przebudzenia" w okresie oczekiwania, przez inny wątek wywołujący notify lub notifyAll.

Jeśli się nad tym zastanowić, nazwy są mylące pod tym względem; jednak sleep jest nazwą standardową i wait jest jak WaitForSingleObject lub WaitForMultipleObjects W Win API.

W prostych słowach, wait to wait, aż inny wątek Cię wywoła, podczas gdy sleep to "dont execute next statement" przez określony czas.

Ponadto sleep jest statyczną metodą w klasie Thread i działa na wątku, podczas gdy wait() jest w klasie obiektu i jest wywołane NA obiekcie.

Kolejny punkt, kiedy wywołujesz wait na jakimś obiekcie, wątek zaangażowany synchronizuje obiekt, a następnie czeka. :)

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

Wait () Metoda.

1) wątek wywołujący metodę wait () zwalnia blokadę, którą posiada.

2) wątek odzyskuje blokadę po wywołaniu przez inne wątki metod notify() lub notifyAll () na tej samej blokadzie.

3) wait () metoda musi być wywołana wewnątrz zsynchronizowanego bloku.

4) wait () metoda jest zawsze wywoływana na obiektach.

5) czekanie wątki mogą być wywoływane przez inne wątki przez wywołanie metody notify () lub notifyAll ().

6) aby wywołać metodę wait (), wątek musi mieć obiekt lock.

Metoda Sleep ()

1) wątek wywołujący metodę sleep () nie zwalnia blokady, którą posiada.

2) metoda sleep () może być wywołana wewnątrz lub poza zsynchronizowanym blokiem.

3) metoda sleep () jest zawsze wywoływana w wątkach.

4) Śpiące wątki nie mogą być obudzone przez inne wątki. Jeśli tak, wątek będzie rzucać przerywaną Exception.

5) aby wywołać metodę sleep (), thread nie musi mieć obiektu lock.

Sen

• powoduje uśpienie bieżącego wątku na określony czas.
[[7]}jego dokładność zależy od czasu i harmonogramów systemowych.
• utrzymuje monitory, które nabył, więc jeśli jest wywoływany z zsynchronizowany kontekst, żaden inny wątek nie może wprowadzić tego bloku lub metody.
• jeśli wywołamy metodę interrupt (), obudzi ona śpiący wątek.

Wait

• powoduje, że prąd wątek, aby czekać, aż któryś z wątków wywoła metoda notify() lub metoda notifyAll () dla tego obiektu
• musi być wywołany z synchronizowanego kontekstu tzn. z bloku lub method.It oznacza, że przed wywołaniem metody wait() bieżący wątek musi namierz ten obiekt.
• zwalnia lock na obiekcie, na którym jest wywoływany i dodawany do lista oczekujących, więc inny wątek może uzyskać blokadę obiektu.

1. wait() jest metodą klasy Object.
   sleep() jest metodą klasy Thread.

2. sleep() pozwala wątkowi przejść do stanu sleep przez X milisekund.
   Gdy wątek przechodzi w stan uśpienia it doesn’t release the lock.

3. wait() pozwala wątkowi zwolnić blokadę i goes to suspended state.
   Ten wątek będzie aktywny, gdy metoda notify() lub notifAll() jest / align = "left" /

Jedna potencjalna duża różnica między snem / przerwaniem a czekaniem / powiadomieniem jest taka, że

• wywołanie interrupt() podczas sleep() zawsze wyrzuca wyjątek (np. InterruptedException ), podczas gdy
• wywołanie notify() podczas wait() nie.

Generowanie wyjątku, gdy nie jest potrzebne, jest nieefektywne. Jeśli masz wątki komunikujące się ze sobą w wysokim tempie, to generowałoby to wiele wyjątków, gdybyś był wywołanie przerwania przez cały czas, co jest całkowitą stratą procesora.

Masz rację - Sleep () powoduje, że wątek jest "uśpiony", a procesor wyłączy się i przetworzy inne wątki (inaczej znane jako przełączanie kontekstu), gdzie moim zdaniem Wait utrzymuje procesor przetwarzający bieżący wątek.

Mamy oba, ponieważ chociaż może wydawać się rozsądne pozwolić innym ludziom korzystać z procesora, gdy go nie używasz, w rzeczywistości istnieje narzut na przełączanie kontekstu - w zależności od tego, jak długo trwa sen, przełączanie wątków może być droższe w cyklach procesora niż jest po prostu mieć swój wątek nic nie robi przez kilka ms.

Zauważ również, że sen wymusza przełączanie kontekstu.

Również-ogólnie nie można kontrolować przełączania kontekstu - Podczas oczekiwania System Operacyjny może (i będzie dłużej czekać) wybrać przetwarzanie innych wątków.

Metody są używane do różnych rzeczy.

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

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

Wątek.sen (n) Może zostać przerwany, ale obiekt.wait () must be notified. Można określić maksymalny czas oczekiwania: Object.wait(5000), więc można by użyć wait do, er, sleep, ale wtedy trzeba się martwić blokadami.

Żadna z metod nie używa procesora podczas snu/oczekiwania.

Metody są zaimplementowane przy użyciu kodu natywnego, przy użyciu podobnych konstrukcji, ale nie w tym samym sposób.

Zobaczcie sami: czy kod źródłowy natywnych metod jest dostępny? plik /src/share/vm/prims/jvm.cpp jest punktem wyjścia...

Tutaj wait() będzie w stanie oczekiwania do momentu powiadomienia przez inny wątek, ale gdzie jako sleep() będzie miał trochę czasu..następnie zostanie automatycznie przeniesiony do stanu gotowości...

Różnice Wait () I sleep ()?

Wątek.sen() Po zakończeniu pracy tylko zwalnia blokadę dla wszystkich. do czasu, aż nigdy nikomu nie wyda zamka.

  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.

Obiekt.czekaj.() Kiedy przejdzie do etapu oczekiwania, zostanie zwolniony klucz i czeka na kilka sekund w oparciu o parametr.

Na Przykład:

Wait(). kiedy jesteś odłożony i wziąć inny jeden oznacza, podczas gdy czekasz, to jest czekać

Odtwarzasz film lub cokolwiek w Twoim systemie tak samo jak odtwarzacz nie możesz odtwarzać więcej niż jednego na raz w prawo, to jego tutaj, kiedy zamykasz i wybierasz inny film lub utwór oznacza, gdy nazywa się czekać

wait zwalnia blokadę i sleep tego nie robi. wątek w stanie oczekiwania jest uprawniony do wybudzenia się zaraz po wywołaniu notify lub notifyAll. Ale w przypadku sleep Wątek zachowuje blokadę i kwalifikuje się dopiero po zakończeniu snu.

sleep() metoda powoduje przejście bieżącego wątku ze stanu uruchomionego do stanu zablokowanego przez określony czas. Jeśli bieżący wątek ma blokadę dowolnego obiektu, to utrzymuje ją, co oznacza, że inne wątki nie mogą wykonać żadnej zsynchronizowanej metody w tym obiekcie klasy.

wait() metoda powoduje, że bieżący wątek przechodzi w stan bloku przez określony czas lub do momentu powiadomienia, ale w tym przypadku wątek zwalnia blokadę obiektu (co oznacza, że inne wątki mogą wykonać dowolne zsynchronizowane metody wywołującego obiektu.

Moim zdaniem główna różnica między obydwoma mechanizmami polega na tym, że sleep/interrupt jest najbardziej podstawowym sposobem obsługi wątków, podczas gdy wait/notify jest abstrakcją mającą na celu ułatwienie komunikacji między wątkami. oznacza to, że sen/przerwanie może zrobić wszystko, ale to konkretne zadanie jest trudniejsze do wykonania.

Dlaczego wait/notify jest bardziej odpowiednie? Oto kilka osobistych rozważań:

1. Wymusza centralizację. pozwala na koordynowanie komunikacja pomiędzy grupą wątków z pojedynczym obiektem współdzielonym. To znacznie upraszcza pracę.

2. Wymusza synchronizację. ponieważ powoduje, że programista zawija wywołanie wait / notify w zsynchronizowany blok.

3. Jest niezależny od pochodzenia i numeru wątku. dzięki temu podejściu możesz dowolnie dodawać więcej wątków bez edytowania innych wątków lub śledzenia istniejących. W przypadku zastosowania opcji sleep / interrupt, najpierw należy musiałby zachować odniesienia do śpiących wątków, a następnie przerywać je jeden po drugim, ręcznie.

Przykładem z prawdziwego życia, który jest dobry, aby wyjaśnić to jest klasyczna restauracja i metoda, którą personel używa do komunikowania się między nimi: kelnerzy zostawiają życzenia klientów w centralnym miejscu (tablica korkowa, stół itp.), dzwoni Dzwonek, a robotnicy z kuchni przychodzą na takie prośby. Gdy nie ma żadnego kursu gotowy, personel kuchni zadzwoń jeszcze raz, aby kelnerzy byli świadomi i zanieśli je do klientów.

Przykład o sleep nie zwalnia blokady i wait robi

Tutaj są dwie klasy:

1. Main : zawiera główną metodę i dwa wątki.

2. Singleton: jest to klasa singleton z dwiema statycznymi metodami getInstance () i 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();
   
    }
   }
   

I

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;

 }
}

Teraz uruchom ten przykład, który otrzymasz poniżej:

_instance :null
Both singleton are same

Tutaj instancje Singletona utworzone przez threadA i threadB są takie same. Oznacza to, że threadB czeka na zewnątrz, aż threadA zwolni blokadę.

Teraz uruchom ponownie:

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

Tutaj instancje Singletona utworzone przez threadA i threadB nie są takie same z powodu threadB dostaĹ 'a siÄ ™ zmiana na enter w zsynchronizowanym bloku i po 500 milisekundach threadA wystartowaĺ' a z ostatniej pozycji i utworzyĹ ' a jeszcze jeden obiekt Singleton.

Powinno być wywołane z synchronizowanego bloku : wait() metoda jest zawsze wywoływana z zsynchronizowanego bloku tzn. wait() metoda musi zablokować obiekt monitor przed obiektem, na którym zostanie wywołana. Ale sleep() metodę można wywołać z zewnątrz zsynchronizowanego bloku tzn. sleep() metoda nie wymaga żadnego monitora obiektu.

IllegalMonitorStateException: jeśli metoda wait() zostanie wywołana bez pozyskania obiektu lock, to IllegalMonitorStateException zostanie rzucona w czasie wykonywania, ale sleep() metoda nigdy nie rzuci takiego wyjątek.

Należy do jakiej klasy : wait() metoda należy do klasy java.lang.Object, Ale sleep() należy do klasy java.lang.Thread.

Wywołane NA obiekcie lub wątku : wait() metoda jest wywoływana na obiektach, ale sleep() metoda jest wywoływana na wątkach, a nie na obiektach.

Stan wątku: gdy metoda wait() jest wywołana na obiekcie, wątek, który przechowywał monitor obiektu przechodzi ze stanu uruchomionego do stanu oczekującego i może powrócić do stanu runnable tylko wtedy, gdy metoda notify() lub notifyAll() jest / align = "left" / A później harmonogram wątków ustawia, że wątek ma przejść ze stanu runnable do running. gdy sleep() jest wywołane w wątku, przechodzi on ze stanu running do waiting i może powrócić do stanu runnable, gdy czas uśpienia dobiega końca.

Wywołanie z zsynchronizowanego bloku: gdy metoda wait() zostanie wywołana wątek opuszcza blokadę obiektu. Ale sleep() metoda wywołana z zsynchronizowanego bloku lub wątku metody nie pozostawia obiektu lock.

Więcej

Ze strony dokumentacji oracle na wait () Metoda Object:

public final void wait()

1. powoduje, że bieżący wątek będzie czekał, aż inny wątek wywoła metodę notify() lub metodę notifyAll() dla tego obiektu. Innymi słowy, metoda ta zachowuje się dokładnie tak, jakby po prostu wykonywała wywołanie wait(0).
2. bieżący wątek musi posiadać monitor tego obiektu. Wątek zwalnia własność tego monitora i czeka aż inny wątek powiadomi wątki oczekujące na monitor tego obiektu to wake up
3. przerywniki i fałszywe przebudzenia są możliwe
4. metoda ta powinna być wywołana tylko przez wątek, który jest właścicielem monitora tego obiektu

Ta metoda rzuca

1. IllegalMonitorStateException - Jeśli bieżący wątek nie jest właścicielem monitora obiektu.

2. InterruptedException - jeśli jakikolwiek wątek przerwał bieżący wątek przed lub gdy bieżący wątek czekał na powiadomienie. Przerwany status bieżący wątek jest czyszczony po wyrzuceniu tego wyjątku.

Ze strony dokumentacji oracle na sleep () metoda Thread klasy:

public static void sleep(long millis)

1. powoduje usypianie aktualnie wykonującego wątku (chwilowe wstrzymanie wykonania) na określoną liczbę milisekund, z zastrzeżeniem precyzji i dokładności czasomierzy i terminarzy systemowych.
2. wątek nie traci własności do żadnych monitorów.

Ta metoda rzuty:

1. IllegalArgumentException - Jeśli wartość Milis jest ujemna

2. InterruptedException - jeśli jakikolwiek wątek przerwał bieżący wątek. Status przerwany bieżącego wątku jest usuwany po wyrzuceniu tego wyjątku.

Inna kluczowa różnica:

wait() jest metodą niestatyczną (metoda instancji) w przeciwieństwie do metody statycznej sleep() (metoda klasy).

• metoda wait(1000) powoduje uśpienie bieżącego wątku do jednej sekundy .
  • wątek może spać mniej niż 1 sekundę, jeśli otrzyma notify() lub notifyAll() wywołanie metody.
[[5]] wezwanie do sleep(1000) powoduje uśpienie bieżącego wątku na dokładnie 1 sekundę .
• również sleeping thread nie przechowuje żadnego zasobu . Ale wątek czekający tak.

wait() jest podana wewnątrz zsynchronizowanej metody podczas gdy {[1] } jest podana wewnątrz niezsynchronizowanej metody, ponieważ metoda wait() zwalnia blokadę obiektu, ale sleep() lub yield() zwalnia lock().