Różnica między stanami wątku WAIT i BLOCKED

Jaka jest różnica między stanem wątku WAIT a stanem wątku ZABLOKOWANY?

Dokumentacja Thread.State :

Zablokowany
Wątek, który jest zablokowany i oczekuje na blokadę monitora, jest w tym stanie.

Oczekiwanie
W tym stanie jest wątek, który czeka w nieskończoność na wykonanie określonej czynności przez inny wątek

nie wyjaśnia mi różnicy.

Wątek przechodzi w stan oczekiwania po wywołaniu wait()obiektu. Nazywa się to stanem oczekiwania . Gdy wątek osiągnie stan oczekiwania, będzie musiał poczekać, aż inne wywołania wątku notify()lub notifyAll()obiekt.

Po powiadomieniu tego wątku nie będzie można go uruchomić. Może się zdarzyć, że inne wątki również są powiadamiane (używają notifyAll()) lub pierwszy wątek nie zakończył swojej pracy, więc nadal jest blokowany, dopóki nie dostanie swojej szansy. Nazywa się to stanem zablokowanym . Stan Zablokowany wystąpi, gdy wątek spróbuje uzyskać blokadę obiektu, a inny wątek już utrzymuje blokadę.

Po opuszczeniu innych wątków i uzyskaniu tej szansy na wątek, przechodzi on do stanu Runnable, po czym kwalifikuje się do podjęcia pracy w oparciu o mechanizm wątków JVM i przechodzi do stanu uruchomienia.

Różnica jest stosunkowo prosta.

W tym BLOCKEDstanie wątek ma zamiar wejść do synchronizedbloku, ale obecnie w synchronizedbloku tego samego obiektu działa inny wątek . Pierwszy wątek musi następnie czekać, aż drugi wątek opuści swój blok.

W tym WAITINGstanie wątek oczekuje na sygnał z innego wątku. Dzieje się to zwykle przez telefon Object.wait()lub Thread.join(). Wątek pozostanie w tym stanie do czasu wywołania innego wątku Object.notify()lub śmierci.

Ważną różnicą między stanami zablokowanymi i oczekującymi jest wpływ na harmonogram. Wątek w stanie zablokowanym walczy o blokadę; ten wątek nadal liczy się jako coś, co planista musi obsłużyć, prawdopodobnie biorąc pod uwagę decyzje planisty dotyczące tego, ile czasu ma dać działającym wątkom (aby mógł dać wątkom blokowanie blokady).

Gdy wątek znajduje się w stanie oczekiwania, obciążenie systemu jest zminimalizowane, a planista nie musi się tym martwić. Przechodzi w stan uśpienia, dopóki nie otrzyma powiadomienia. Z wyjątkiem faktu, że utrzymuje zajęty wątek systemu operacyjnego, jest całkowicie poza grą.

To dlatego użycie notifyAll jest mniej niż idealne, powoduje, że kilka wątków, które wcześniej były szczęśliwie uśpione, nie obciążały systemu, aby się obudzić, gdzie większość z nich będzie blokować, dopóki nie zdobędą blokady, znajdą stan, w którym są czekanie nie jest prawdą i wróć do czekania. Lepiej byłoby powiadamiać tylko te wątki, które mają szansę na postęp.

(Użycie ReentrantLock zamiast wewnętrznych blokad pozwala mieć wiele warunków dla jednej blokady, dzięki czemu można upewnić się, że powiadomiony wątek jest tym, który czeka na określony warunek, unikając błędu zgubienia powiadomienia w przypadku powiadomienia o wątku coś, na co nie może działać.)

Uproszczona perspektywa interpretacji zrzutów wątków:

• CZEKAJ - czekam na pracę, więc jestem teraz bezczynny.
  
• ZABLOKOWANE - Jestem zajęty wykonywaniem pracy, ale na drodze stoi mi inny wątek, więc jestem teraz bezczynny.
  
• RUNNABLE ... (metoda rodzima ) - wezwałem URUCHOMIĆ kod natywny (który jeszcze się nie skończył), więc jeśli chodzi o JVM, jesteś RUNNABLE i nie może podać żadnych dalszych informacji. Typowym przykładem może być natywna metoda nasłuchiwania gniazd zakodowana w C, która faktycznie czeka na nadejście jakiegokolwiek ruchu, więc jestem teraz bezczynny. W tej sytuacji można to postrzegać jako specjalny rodzaj CZEKANIA, ponieważ w rzeczywistości wcale NIE URUCHAMIAMY (brak spalania procesora), ale aby to zobaczyć, trzeba użyć zrzutu wątku systemu operacyjnego zamiast zrzutu wątku Java.

Zablokowany - Twój wątek znajduje się w stanie gotowości do uruchomienia i próbuje uzyskać blokadę obiektu. Czekaj - Twój wątek jest w stanie oczekiwania na cykl życia wątku i czeka na sygnał powiadamiający, aby przejść w stan gotowości wątku do uruchomienia.

zobacz ten przykład:

demonstracja stanów wątku.

/*NEW- thread object created, but not started.
RUNNABLE- thread is executing.
BLOCKED- waiting for monitor after calling wait() method.
WAITING- when wait() if called & waiting for notify() to be called.
  Also when join() is called.
TIMED_WAITING- when below methods are called:
 Thread.sleep
 Object.wait with timeout
 Thread.join with timeout
TERMINATED- thread returned from run() method.*/
public class ThreadBlockingState{

public static void main(String[] args) throws InterruptedException {
    Object obj= new Object();
    Object obj2 = new Object();
    Thread3 t3 = new Thread3(obj,obj2);
    Thread.sleep(1000);
    System.out.println("nm:"+t3.getName()+",state:"+t3.getState().toString()+
            ",when Wait() is called & waiting for notify() to be called.");
    Thread4 t4 = new Thread4(obj,obj2);
    Thread.sleep(3000);
    System.out.println("nm:"+t3.getName()+",state:"+t3.getState().toString()+",After calling Wait() & waiting for monitor of obj2.");
    System.out.println("nm:"+t4.getName()+",state:"+t4.getState().toString()+",when sleep() is called.");
}

}
class Thread3 extends Thread{
Object obj,obj2;
int cnt;
Thread3(Object obj,Object obj2){
    this.obj = obj;
    this.obj2 = obj2;
    this.start();
}

@Override
public void run() {
    super.run();
    synchronized (obj) {
        try {
            System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",Before Wait().");
            obj.wait();             
            System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",After Wait().");
            synchronized (obj2) {
                cnt++;
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}
class Thread4 extends Thread{
Object obj,obj2;
Thread4(Object obj,Object obj2){
    this.obj = obj;
    this.obj2 = obj2;
    this.start();
}

@Override
public void run() {
    super.run();
    synchronized (obj) {
        System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",Before notify().");
        obj.notify();
        System.out.println("nm:"+this.getName()+",state:"+this.getState().toString()+",After notify().");
    }
    synchronized (obj2) {
        try {
            Thread.sleep(15000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
}