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

Jaka jest różnica między wait()a sleep()w wątkach?

Czy rozumiem, że wait()wątek -ing wciąż działa w trybie roboczym i używa cykli procesora, ale sleep()-ing nie zużywa żadnych cykli procesora?

Dlaczego mamy jedno wait() i drugiesleep() : w jaki sposób ich wdrożenie różni się na niższym poziomie?

A waitmoże zostać „obudzony” przez inny wątek wzywający notifymonitor, na który czeka się, podczas gdy sleepnie. Również wait(i notify) musi się zdarzyć w bloku synchronizedobiektu monitora, podczas sleepgdy nie:

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

W tym momencie aktualnie wykonywany wątek czeka i zwalnia monitor . Może zrobić inny wątek

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

(na tym samym monobiekcie) i pierwszy wątek (zakładając, że jest to jedyny wątek oczekujący na monitorze) się obudzi.

Możesz także zadzwonić, notifyAlljeśli więcej niż jeden wątek czeka na monitorze - to obudzi je wszystkie . Jednak tylko jeden wątek będzie w stanie chwycić monitor (pamiętaj, że waitjest w synchronizedbloku) i kontynuować - pozostałe zostaną zablokowane, dopóki nie uzyskają blokady monitora.

Inną kwestią jest to, że zadzwonisz waitna Objectsiebie (to znaczy czekać na monitorze obiekt za), natomiast zadzwonić sleepna Thread.

Jeszcze innym jest to, że można dostać fałszywych wybudzeń z wait(tj wątku czeka CV bez wyraźnego powodu). Powinieneś zawsze waitpodczas przędzenia na jakimś stanie w sposób następujący:

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

Jedną kluczową różnicą, o której jeszcze nie wspomniano, jest to, że podczas uśpienia Wątek nie zwalnia blokad, które trzyma, podczas oczekiwania zwalnia blokadę na wait()wywołanym obiekcie .

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


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

Uznałem ten post za pomocny. Stawia różnicę pomiędzy Thread.sleep(), Thread.yield()oraz Object.wait()w kategoriach ludzkich. Cytować:

Wszystko to ostatecznie dociera do harmonogramu systemu operacyjnego, który rozdaje przedziały czasu dla procesów i wątków.

sleep(n)mówi: „Skończyłem ze szczelinami czasowymi i proszę, nie dawaj mi kolejnego przez co najmniej n milisekund”.System operacyjny nie próbuje nawet zaplanować uśpionego wątku, dopóki nie upłynie żądany czas.

yield()mówi: „Skończyłem z czasem, ale wciąż mam do zrobienia”.System operacyjny może od razu podać wątkowi inny przedział czasu lub podać inny wątek lub przetworzyć procesor, który zrezygnował z wątku.

wait()mówi „Skończyłem z czasem. Nie dawaj mi kolejnego przedziału czasu, dopóki ktoś nie zadzwoni powiadomić (). ” Podobnie jak w przypadku sleep(), system operacyjny nie będzie nawet próbował zaplanować twojego zadania, chyba że ktoś zadzwoninotify() (lub wystąpi jeden z kilku innych scenariuszy budzenia).

Wątki tracą także pozostałą część czasu, gdy wykonują blokowanie IO i w kilku innych okolicznościach. Jeśli wątek działa przez cały przedział czasu, system operacyjny siłą przejmuje kontrolę z grubsza tak, jakbyyield() został wywołany, aby mogły działać inne procesy.

Rzadko potrzebujesz yield(), ale jeśli masz aplikację wymagającą dużej mocy obliczeniowej z logicznymi granicami zadań, wstawienie yield() może poprawić czas reakcji systemu (kosztem czasu - przełączanie kontekstu, nawet tylko na system operacyjny iz powrotem, nie jest bezpłatne). Jak zawsze mierz i testuj cele, na których Ci zależy.

Jest tu wiele odpowiedzi, ale nie mogłem znaleźć wyróżnienia semantycznego, o którym mowa.

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 tryb uśpienia, tak jak wcześniej, po prostu pakuje kontekst i przestaje działać na określony czas. Aby obudzić go przed upływem czasu, musisz znać odniesienie do wątku. To nie jest typowa sytuacja w środowisku wielowątkowym. Jest to najczęściej używane do synchronizacji czasu (np. Obudzić się dokładnie w 3,5 sekundy) i / lub zakodowanej uczciwości (po prostu śpij przez chwilę i pozwól innym wątkom działać).

wait(), wręcz przeciwnie, jest mechanizmem synchronizacji wątku (lub wiadomości), który pozwala powiadomić Wątek, o którym nie masz zapisanego odniesienia (ani opieki). Możesz to traktować jako wzorzec publikowania-subskrybowania ( wait== subskrybuj inotify() == publikuj). Zasadniczo za pomocą powiadomienia () wysyłasz wiadomość (która może nawet nie zostać odebrana i zwykle nie obchodzi Cię to).

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

Mogą być zaimplementowane w ten sam sposób w podstawowym systemie operacyjnym lub wcale (ponieważ poprzednie wersje Java nie miały prawdziwej wielowątkowości; prawdopodobnie niektóre małe maszyny wirtualne też tego nie robią). Nie zapominaj, że Java działa na maszynie wirtualnej, więc Twój kod zostanie przekształcony w coś innego, zgodnie z VM / OS / HW, na którym działa.

Tutaj mam wymienione kilka ważnych różnic wait()i sleep()metod.
PS: Kliknij również na linki, aby zobaczyć kod biblioteki (działa wewnętrznie, po prostu pobaw się trochę dla lepszego zrozumienia).

czekać()

1. wait() Metoda zwalnia blokadę.
2. wait()jest metodą Objectklasy.
3. wait() jest metodą niestatyczną - public final void wait() throws InterruptedException { //...}
4. wait()należy powiadomić za pomocą notify()lub notifyAll()metod.

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

6. wait() Metoda musi być wywołana z kontekstu synchronizowanego (tj. zsynchronizowana metoda lub blok), w przeciwnym razie wyrzuci IllegalMonitorStateException

sen()

1. sleep() Metoda nie zwalnia blokady.
2. sleep()jest metodą java.lang.Threadklasy.
3. sleep() jest metodą statyczną - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
4. po określonym czasie sleep() zostanie zakończone.
5. sleep()lepiej nie dzwonić z pętli (tj. patrz kod poniżej ).
6. sleep()może być wywoływany z dowolnego miejsca. nie ma szczególnych wymagań.

Ref: Różnica między oczekiwaniem a snem

Fragment kodu do wywołania metody oczekiwania i uśpienia

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

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

Istnieją pewne kluczowe notatki różnicowe, które podsumowuję po pracy nad czekaniem i snem, najpierw spójrz na próbkę za pomocą wait () i sleep ():

Przykład 1 : użycie funkcji 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();
}

Niech klarowność zawiera kilka kluczowych uwag:

1. Wezwać :
   • wait (): Wywołanie bieżącego wątku zawierającego obiekt HandObject
   • sleep (): Wywołanie zadania wykonywania wątku get beer (metoda klasy, więc wpływ na bieżący działający wątek)
2. Zsynchronizowane :
   • wait (): po zsynchronizowanym dostępie do wielu wątków ten sam obiekt (HandObject) (gdy potrzebna jest komunikacja między więcej niż jednym wątkiem (kodowanie wątku, wykonanie wątku uzyskać piwo) dostęp do tego samego obiektu HandObject)
   • sleep (): gdy warunek oczekiwania jest kontynuowany (dostępne piwo oczekujące)
3. Przytrzymaj blokadę :
   • wait (): zwolnij blokadę, aby inny obiekt miał szansę wykonać (HandObject jest darmowy, możesz wykonać inną pracę)
   • sleep (): trzymaj blokadę co najmniej t razy (lub aż do przerwania) (Moje zadanie wciąż się nie kończy, kontynuuję blokadę i czekam na pewien warunek, aby kontynuować)
4. Stan budzenia :
   • wait (): aż do wywołania powiadomienia (), replaceAll () z obiektu
   • sleep (): do upłynięcia przynajmniej czasu lub przerwania połączenia
5. Ostatnim punktem jest użycie, gdy jak estani wskazują:

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

Proszę popraw mnie jeżeli się mylę.

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

• Podstawową różnicą jest to, że wait()pochodzi Objecti 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()ogólnie służy do wprowadzania pauzy przy wykonywaniu.

• wait()należy wywołać od wewnątrz synchronizować, albo dostaniemy IllegalMonitorStateExceptionchwilęsleep() można wywołać w dowolnym miejscu.

• Aby ponownie rozpocząć wątek wait(), musisz zadzwonić notify()lub notifyAll(). Co do sleep(),wątku zaczyna się po określonym przedziale czasu.

Podobieństwa

• Oba sprawiają, że bieżący wątek przechodzi w Not Runnable .
• Obie są metodami natywnymi .

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

Główną różnicą jest oczekiwanie na zwolnienie blokady lub monitora, podczas gdy sen nie zwalnia żadnej blokady ani monitora podczas oczekiwania. Czekanie służy do komunikacji między wątkami, podczas gdy sen służy do wprowadzenia pauzy przy wykonywaniu.

To było tylko jasne i podstawowe wyjaśnienie, jeśli chcesz czegoś więcej, czytaj dalej.

W przypadku wait()metody wątek przechodzi w stan oczekiwania i nie wróci automatycznie, dopóki nie wywołamy notify()metody (lub notifyAll()jeśli masz więcej niż jeden wątek w stanie oczekiwania i chcesz obudzić wszystkie te wątki). I trzeba zsynchronizować lub blokady obiektu lub blokada klasa Aby uzyskać dostęp do wait()albo notify()lub notifyAll()metod. I jeszcze jedno:wait() metoda jest używana do komunikacji między wątkami, ponieważ jeśli wątek przejdzie w stan oczekiwania, potrzebny będzie inny wątek, aby go obudzić.

Ale w takim przypadku sleep()jest to metoda używana do wstrzymania procesu przez kilka sekund lub żądany czas. Ponieważ nie musisz prowokować żadnej metody notify()ani notifyAll()metody odzyskania tego wątku. Lub nie potrzebujesz żadnego innego wątku, aby go oddzwonić. Na przykład, jeśli chcesz, aby coś się wydarzyło po kilku sekundach, np. W grze po kolejce użytkownika, chcesz, aby użytkownik czekał na uruchomienie komputera, możesz wspomniećsleep() metodzie.

I jeszcze jedna ważna różnica, o którą często pytamy w wywiadach: sleep()należy do Threadklasy i wait()należy doObject klasy.

To są wszystkie różnice między sleep()iwait() .

I istnieje podobieństwo między obiema metodami: obie są sprawdzane, więc musisz spróbować złapać lub rzucić, aby uzyskać dostęp do tych metod.

Mam nadzieję, że to Ci pomoże.

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

Thread.sleep()wysyła bieżący wątek do stanu „Nie można uruchomić ” przez pewien czas. Wątek zachowuje monitory, które uzyskał - tzn. Jeśli wątek jest obecnie w synchronizowanym bloku lub metodzie, żaden inny wątek nie może wejść do tego bloku lub metody. Jeśli zadzwoni inny wątekt.interrupt() , obudzi uśpiony wątek.

Pamiętaj, że uśpienie jest metodą statyczną, co oznacza, że ​​zawsze wpływa na bieżący wątek (ten, który wykonuje metodę uśpienia). Częstym błędem jest wywoływanie, t.sleep()gdzie t jest innym wątkiem; nawet wtedy uśpiony zostanie bieżący wątek, a nie wątek t.

t.suspend()jest przestarzałe. Za pomocą tego można zatrzymać wątek inny niż bieżący. Zawieszony wątek zachowuje wszystkie monitory, a ponieważ ten stan nie jest przerywany, jest podatny na zakleszczenie.

object.wait()wysyła bieżący wątek do stanu „Not Runnable” , jak sleep(), ale z niespodzianką. Czekanie jest wywoływane na obiekcie, a nie na wątku; nazywamy ten obiekt „obiektem blokady”. Przed lock.wait()wywołaniem bieżący wątek musi zsynchronizować się z obiektem blokady; wait() następnie zwalnia tę blokadę i dodaje wątek do „listy oczekujących” powiązanej z blokadą. Później inny wątek może zsynchronizować ten sam obiekt blokady i wywołanie 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, a jedynie do wspólnego obiektu blokady.

Czekaj i śpij to dwie różne rzeczy:

• W sleep() wątku przestaje działać na określony czas.
• W wait()wątku przestaje działać aż istota Przedmiotem czekał na zostaje zgłoszone, zasadniczo innych nici.

sleepjest metodą Thread, waitjest metodą Object, podobnie wait/notifyjak technika synchronizacji danych udostępnionych w Javie (przy użyciu monitora ), ale sleepjest prostą metodą wątku, aby się zatrzymać.

sleep () jest metodą używaną do zatrzymania procesu przez kilka sekund lub żądany czas, ale w przypadku metody wait () wątek przechodzi w stan oczekiwania i nie wróci automatycznie, dopóki nie wywołamy powiadomienia () lub replaceAll ().

Główną różnicą jest to, że wait () zwalnia blokadę lub monitora podczas snu () nie zwalnia żadnej blokady lub monitora podczas oczekiwania. Czekanie służy do komunikacji między wątkami, podczas gdy sen jest używany do wprowadzenia pauzy w trakcie wykonywania.

Thread.sleep () wysyła bieżący wątek do stanu „Not Runnable” przez pewien czas. Wątek utrzymuje zgromadzone monitory - tzn. Jeśli wątek jest obecnie w zsynchronizowanym bloku lub metodzie, żaden inny wątek nie może wejść do tego bloku lub metody. Jeśli inny wątek wywoła t.interrupt (), obudzi uśpiony wątek. Pamiętaj, że uśpienie jest metodą statyczną, co oznacza, że ​​zawsze wpływa na bieżący wątek (ten, który wykonuje metodę uśpienia). Częstym błędem jest wywołanie t.sleep (), gdzie t jest innym wątkiem; nawet wtedy uśpiony zostanie bieżący wątek, a nie wątek t.

object.wait () wysyła bieżący wątek do stanu „Not Runnable”, jak sleep (), ale z niespodzianką. Czekanie jest wywoływane na obiekcie, a nie na wątku; nazywamy ten obiekt „obiektem blokady”. Przed wywołaniem funkcji lock.wait () bieżący wątek musi zsynchronizować się z obiektem blokady; wait () następnie zwalnia tę blokadę i dodaje wątek do „listy oczekujących” powiązanej z blokadą. Później inny wątek może zsynchronizować ten sam obiekt blokady i wywołać funkcję lock.notify (). To budzi oryginalny, oczekujący wątek. Zasadniczo czekanie () / powiadomienie () jest jak sleep () / interrupt (), tylko aktywny wątek nie potrzebuje bezpośredniego wskaźnika do uśpionego wątku, ale tylko do obiektu blokady współużytkowanej.

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

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

Pozwól kategoryzować wszystkie powyższe punkty:

Call on:

• wait (): Wywołanie obiektu; bieżący wątek musi zostać zsynchronizowany na obiekcie blokady.
• sleep (): Wywołanie wątku; zawsze aktualnie wykonuje wątek.

Synchronized:

• wait (): po zsynchronizowaniu wielu wątków uzyskaj dostęp do tego samego obiektu jeden po drugim.
• sleep (): po zsynchronizowaniu wielu wątków poczekaj na zakończenie uśpienia wątku.

Hold lock:

• wait (): zwolnij blokadę, aby inne obiekty miały szansę wykonać.
• sleep (): trzymaj blokadę co najmniej t razy, jeśli określono limit czasu lub ktoś przerwie.

Wake-up condition:

• wait (): aż do wywołania powiadomienia (), replaceAll () z obiektu
• sleep (): do upłynięcia przynajmniej czasu lub przerwania połączenia ().

Usage:

• sleep (): do synchronizacji czasu i;
• wait (): dla synchronizacji wielowątkowej.

Ref: diff sleepiwait

Krótko mówiąc, czekaj to czekaj, dopóki inny wątek cię nie wywoła, podczas gdy sen to „nie wykonuj następnej instrukcji” przez określony czas.

Ponadto sleep jest metodą statyczną w klasie Thread i działa na wątku, podczas gdy wait () znajduje się w klasie Object i jest wywoływany na obiekcie.

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

waiti sleepmetody są bardzo różne:

• sleep nie ma możliwości „przebudzenia”,
• podczas gdy waitma sposób na „przebudzenie” podczas okresu oczekiwania przez inny wątek notifylub notifyAll.

Pomyśl o tym, nazwy są mylące pod tym względem; jednak sleepto standardowa nazwa i waitjest jak WaitForSingleObjectalbo WaitForMultipleObjectsw Win API.

Z tego postu: http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

Metoda wait ().

1) Wątek, który wywołuje metodę wait (), zwalnia blokadę.

2) Wątek odzyskuje blokadę po tym, jak inne wątki wywołują metody powiadomienia () lub notyfikuj wszystkie () na tej samej blokadzie.

3) W ramach synchronizowanego bloku należy wywołać metodę wait ().

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

5) Oczekiwane wątki mogą zostać obudzone przez inne wątki, wywołując metody notice () lub replaceAll ().

6) Aby wywołać metodę wait (), wątek musi mieć blokadę obiektu.

Metoda sleep ()

1) Wątek, który wywołuje metodę sleep (), nie zwalnia blokady, którą trzyma.

2) metodę sleep () można wywołać w obrębie synchronizowanego bloku lub poza nim.

3) Metoda sleep () jest zawsze wywoływana dla wątków.

4) Śpiące wątki nie mogą zostać obudzone przez inne wątki. Jeśli to zrobisz, wątek zgłosi wyjątek InterruptedException.

5) Aby wywołać metodę sleep (), wątek nie musi mieć blokady obiektu.

1. wait()jest metodą Objectklasy.
   sleep()jest metodą Threadklasy.

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

3. wait()pozwala nić zwolnić blokadę i goes to suspended state.
   Wątek będzie aktywny, gdy zostanie wywołana metoda notify()lub notifAll()dla tego samego obiektu.

Jedną z potencjalnych dużych różnic między trybem uśpienia / przerwania a oczekiwaniem / powiadomieniem jest to

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

Generowanie wyjątku, gdy nie jest potrzebne, jest nieefektywne. Jeśli masz wątki komunikujące się ze sobą z dużą prędkością, generowanie wielu wyjątków powodowałoby ciągłe wywoływanie przerwania, co jest całkowitym marnotrawstwem procesora.

Masz rację - Sleep () powoduje, że wątek przechodzi w stan „uśpienia”, a procesor wyłącza się i przetwarza inne wątki (inaczej zwane przełączaniem kontekstu), jak sądzę, Wait utrzymuje procesor przetwarzający bieżący wątek.

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

Zauważ też, że sen wymusza zmianę kontekstu.

Ponadto - generalnie nie jest możliwe sterowanie przełączaniem kontekstu - podczas oczekiwania system operacyjny może (i będzie dłużej oczekiwał) 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.

Thread.sleep (n) można przerwać, ale Object.wait () musi zostać powiadomiony. Możliwe jest określenie maksymalnego czasu oczekiwania: Object.wait(5000)więc można by użyć wait, er, sleepale wtedy trzeba zawracać sobie głowę blokadami.

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

Metody są implementowane przy użyciu kodu natywnego, przy użyciu podobnych konstrukcji, ale nie w ten sam sposób.

Szukaj sam: czy dostępny jest kod źródłowy metod natywnych? Plik /src/share/vm/prims/jvm.cppjest punktem początkowym ...

Tutaj wait () będzie w stanie oczekiwania, dopóki nie powiadomi o tym inny wątek, ale gdzie jako sleep () będzie miał trochę czasu .. po tym, gdy automatycznie przejdzie w stan gotowości ...

Różnice oczekiwania () i snu ()?

Thread.sleep () Po zakończeniu pracy tylko zwolnij zamek dla wszystkich. dopóki nie zwolni nikogo z blokady.

  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 () Gdy przejdzie do etapu oczekiwania, zwolni klucz i będzie czekał przez kilka sekund na podstawie parametru.

Na przykład:

bierzesz kawę w prawą rękę, możesz wziąć inną osobę z tej samej ręki, kiedy odłożysz, zabierz tylko inny przedmiot tego samego typu. również. to jest sen () śpisz czas nie pracowałeś, robisz tylko spanie ... to samo tutaj również.

czekać(). kiedy jesteś przygnębiony i bierzesz inny środek, gdy czekasz, to czekaj

grasz film lub cokolwiek w swoim systemie tak samo jak odtwarzacz, nie możesz odtwarzać więcej niż jednego naraz, to jest tutaj, kiedy zamykasz i wybierasz inny dowolny film lub utwór, podczas gdy nazywa się czekać

waitzwalnia blokadę i sleepnie. Wątek w stanie oczekiwania może się obudzić natychmiast po wywołaniu notifylub notifyAll. Ale w przypadku sleepnici utrzymuje blokadę i będzie kwalifikować się dopiero po upływie czasu snu.

sleep()Metoda powoduje przejście bieżącego wątku ze stanu roboczego do stanu zablokowania na określony czas. Jeśli bieżący wątek ma blokadę dowolnego obiektu, wówczas go trzyma, 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 albo na określony czas, albo do powiadomienia, ale w tym przypadku wątek zwalnia blokadę obiektu (co oznacza, że ​​inne wątki mogą wykonywać dowolne zsynchronizowane metody obiektu wywołującego.

Moim zdaniem główna różnica między obydwoma mechanizmami polega na tym, że tryb uśpienia / przerwania jest najbardziej podstawowym sposobem obsługi wątków, podczas gdy oczekiwanie / powiadomienie to abstrakcja mająca na celu ułatwienie komunikacji między wątkami. Oznacza to, że sen / przerwanie może zrobić wszystko, ale trudniejsze jest wykonanie tego konkretnego zadania.

Dlaczego oczekiwanie / powiadomienie jest bardziej odpowiednie? Oto kilka osobistych uwag:

1. Wymusza centralizację. Pozwala na koordynację komunikacji między grupą wątków za pomocą pojedynczego obiektu wspólnego. To bardzo upraszcza pracę.

2. Wymusza synchronizację. Ponieważ zmusza programistę do zawinięcia połączenia w celu oczekiwania / powiadomienia w zsynchronizowanym bloku.

3. Jest niezależny od pochodzenia i numeru wątku. Dzięki takiemu podejściu możesz dowolnie dodawać więcej wątków bez edytowania innych wątków lub śledzenia istniejących. Jeśli używałeś trybu uśpienia / przerwania, najpierw musisz zachować odniesienia do uśpionych wątków, a następnie przerwać je pojedynczo, ręcznie.

Przykładem z prawdziwego życia, który warto wyjaśnić, jest klasyczna restauracja i metoda, którą pracownicy używają do komunikowania się między nimi: kelnerzy pozostawiają życzenia klientów w centralnym miejscu (tablica korkowa, stół itp.), zadzwonić, a pracownicy z kuchni przychodzą, aby przyjąć takie prośby. Po przygotowaniu kursu personel kuchni ponownie dzwoni, aby kelnerzy byli świadomi i zabrali go do klientów.

Przykład dotyczący snu nie zwalnia blokady, a czeka

Oto 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, uzyskasz wynik poniżej:

_instance :null
Both singleton are same

W tym przypadku wystąpienia Singleton utworzone przez wątek A i wątek B są takie same. Oznacza to, że wątek B czeka na zewnątrz, aż wątek A zwolni blokadę.

Teraz zmień Singleton.java, komentując Thread.sleep (500); metoda i odkomentowanie Singleton.class.wait (500); . Tutaj z powodu Singleton.class.wait (500); metoda threadA zwolni wszystkie blokady i przejdzie w stan „Non Runnable”, wątek B dostanie zmianę do wprowadzenia w bloku synchronicznym.

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

W tym przypadku instancje Singleton utworzone przez wątek A i wątek NIE są takie same, ponieważ wątek B otrzymał zmianę, aby wejść do bloku synchronicznego i po 500 milisekundach wątek A zaczął od swojej ostatniej pozycji i utworzył jeszcze jeden obiekt Singleton.

Powinny być wywoływane z bloku zsynchronizowanego: wait() metoda jest zawsze wywoływana z bloku zsynchronizowanego, tzn. wait()Metoda musi zablokować monitor obiektu przed obiektem, na którym jest wywoływana. Ale sleep()metodę można wywołać z zewnętrznego synchronizowanego bloku, tzn. sleep()Metoda nie wymaga monitorowania obiektu.

IllegalMonitorStateException: jeśli wait()metoda jest wywoływana bez uzyskiwania blokady obiektu, niż IllegalMonitorStateExceptionjest generowana w czasie wykonywania, ale sleep()metoda nigdy nie zgłasza takiego wyjątku.

Należy do której klasy: wait() metoda należy do java.lang.Objectklasy, ale sleep()metoda należy do java.lang.Threadklasy.

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

Stan wątku: gdy wait()metoda jest wywoływana na obiekcie, wątek, który trzymał monitor obiektu przechodzi od stanu uruchomionego do stanu oczekiwania i może powrócić do stanu wykonalnego tylko wtedy, gdy notify()lub obiekt notifyAll()zostanie wywołany na tym obiekcie. Później harmonogram wątków planuje przejście tego wątku ze stanu uruchomionego do uruchomionego. kiedy sleep()nazywa się na wątku przechodzi od stanu wykonywania do czekania i może powrócić do stanu runnable gdy czas snu jest gotowy.

W przypadku wywołania z bloku synchronicznego: w przypadku wait()wywołania metody wątek opuszcza blokadę obiektu. Ale sleep()metoda wywołana z synchronizowanego bloku lub wątku metody nie pozostawia blokady obiektu.

Aby uzyskać więcej Referencje

Ze strony dokumentacji Oracle w metodzie wait ()Object :

public final void wait()

1. Powoduje, że bieżący wątek czeka, aż inny wątek wywoła notify()metodę lub notifyAll()metodę dla tego obiektu. Innymi słowy, ta metoda zachowuje się dokładnie tak, jakby po prostu wykonała wywołanie wait(0).
2. Bieżący wątek musi być właścicielem monitora tego obiektu. Wątek zwalnia własność tego monitora i czeka, aż inny wątek powiadomi wątki oczekujące na monitorze tego obiektu, aby się obudził
3. możliwe są przerwania i fałszywe budzenie
4. Ta metoda powinna być wywoływana 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 w trakcie, gdy bieżący wątek czekał na powiadomienie. Status przerwania bieżącego wątku jest usuwany po zgłoszeniu tego wyjątku.

Ze strony dokumentacji Oracle w metodzie sleep ()Thread klasy:

public static void sleep(long millis)

1. Powoduje uśpienie aktualnie wykonującego się wątku (tymczasowe wstrzymanie wykonywania) na określoną liczbę milisekund, z zastrzeżeniem precyzji i dokładności systemowych zegarów i harmonogramów.
2. Wątek nie traci własności żadnych monitorów.

Ta metoda rzuca:

1. IllegalArgumentException - jeżeli wartość millis jest ujemna

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

Inna kluczowa różnica:

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

wait()jest umieszczona pomiędzy zsynchronizowany sposób, podczas gdy sleep()podaje się wewnątrz nie zsynchronizowany sposób, ponieważ wait()sposób zwolnić blokadę obiektu, ale sleep()i yield()zwalnia lock().

• Metoda wait(1000)powoduje uśpienie bieżącego wątku do jednej sekundy .
  • Wątek może spać krócej niż 1 sekundę, jeśli odbierze wywołanie metody notify()lubnotifyAll() metody.
• Wywołanie opcji sleep(1000)powoduje uśpienie bieżącego wątku na dokładnie 1 sekundę .
  • Również uśpiony wątek nie blokuje żadnego zasobu . Ale oczekujący wątek tak.

W rzeczywistości wszystko to jest jasno opisane w dokumentach Java (ale zrozumiałem to dopiero po przeczytaniu odpowiedzi).

http://docs.oracle.com/javase/8/docs/api/index.html :

wait () - bieżący wątek musi posiadać monitor tego obiektu. Wątek zwalnia prawo własności do tego monitora i czeka, aż inny wątek powiadomi wątki oczekujące na monitorze tego obiektu, aby się obudził albo przez wywołanie metody notyfikacji, albo metody notyfikowania wszystkich. Wątek czeka następnie, aż będzie mógł odzyskać własność monitora i wznowi wykonywanie.

sleep () - Powoduje uśpienie aktualnie wykonywanego wątku (czasowo wstrzymaj wykonywanie) na określoną liczbę milisekund, z zastrzeżeniem precyzji i dokładności systemowych liczników czasu i harmonogramów. Wątek nie traci własności żadnych monitorów.