Різниця між станами потоку WAIT і BLOCKED

Яка різниця між станом потоку ЗАЧЕКАЙТЕ і станом потоку БЛОКОВАНО?

Документація щодо теми :

Заблоковано
Нитка, яка заблокована в очікуванні блокування монітора, знаходиться в такому стані.

Очікування
Нитка, яка чекає нескінченно часу, щоб інша нитка виконала певну дію, знаходиться в цьому стані

не пояснює мені різниці.

Нитка переходить у стан очікування, коли вона викликає wait()Об'єкт. Це називається держава очікування . Як тільки нитка досягне стану очікування, їй потрібно буде зачекати, доки інший потік дзвонить notify()або notifyAll()на об'єкт.

Після повідомлення про цю нитку вона не підлягає застосуванню. Можливо, про інші потоки також повідомляється (використовується notifyAll()) або перший потік не закінчив свою роботу, тому він все ще блокується, поки не отримає свій шанс. Це називається Заблокований стан. Блокований стан буде виникати, коли нитка намагається придбати замок на об'єкті, а якийсь інший потік вже тримає замок.

Після того, як інші потоки залишилися і вона має шанс цього потоку, вона переходить у стан Runnable, після чого вона може підібрати роботу на основі механізму різьблення JVM і переходить у стан запуску.

Різниця порівняно проста.

У BLOCKEDстані нитка збирається ввести synchronizedблок, але всередині іншої потоки працює інший потікsynchronized блоку того ж об'єкта. Перший потік повинен зачекати, поки другий потік вийде з його блоку.

У WAITINGстані нитка чекає сигналу від іншої нитки. Зазвичай це відбувається за допомогою дзвінка Object.wait(), або Thread.join(). Потім потік залишатиметься в такому стані, поки інший потік не викликає Object.notify()або не відмирає.

Важлива відмінність заблокованого стану та стану очікування - це вплив на планувальник. Нитка в заблокованому стані претендує на замок; цей потік все ще вважається чимось, що планувальник повинен обслуговувати, можливо, враховуючи рішення планувальника про те, скільки часу надавати запущеним потокам (щоб він міг дати шанс блокування потоків на блоці).

Після того, як нитка перебуває в стані очікування, напруга, яку вона надає системі, зводиться до мінімуму, і планувальникові не потрібно про це турбуватися. Він перебуває в спокої, поки не отримає повідомлення. За винятком того, що він тримає нитку ОС зайнятою, вона повністю не грає.

Ось чому використання notifyAll є менш ніж ідеальним, це призводить до того, що низка потоків, які раніше були щасливо дрімаючими, не ставлячи навантаження на систему, щоб прокинутися, де більшість із них заблокує, поки вони не зможуть придбати замок, знайти стан, у якому вони є чекати неправда, і повернутися до очікування. Бажано повідомити лише ті теми, які мають шанс прогресувати.

(Використання ReentrantLock замість внутрішніх блокувань дозволяє вам мати кілька умов для одного блокування, так що ви можете переконатися, що сповіщена нитка є такою, яка чекає за певної умови, уникаючи помилки втраченого сповіщення у випадку отримання потоком повідомлень про щось, на що не може діяти.)

Спрощена перспектива для інтерпретації відвалів потоків:

• ЗАЧЕКАЙ - чекаю, що мені дадуть якусь роботу, тому я зараз простою.
  
• Блокований - я зайнятий спробами закінчити роботу, але інша нитка стоїть на моєму шляху, тому я простою зараз.
  
• RUNNABLE ... (Native Method) - Я закликав RUN деякий нативний код (який ще не закінчений), що стосується JVM, ви RUNNABLE і він не може дати більше інформації. Поширеним прикладом може бути метод рідного слухача сокетів, закодований в C, який насправді чекає прибуття будь-якого трафіку, тому я зараз простою. У цій ситуації це може розглядатися як особливий вид ЗАЧЕКАЙТЕ, оскільки ми насправді НЕ РАБОЧИМ (немає запису процесора) взагалі, але вам доведеться використовувати дамп потоку ОС, а не дамп потоку Java, щоб побачити це.

Заблоковано - Ваш потік перебуває у стані експлуатації потоку життєвого циклу потоку та намагається отримати блокування об'єкта. Зачекайте - Ваш потік знаходиться в стані очікування життєвого циклу потоку і чекає, коли сигнал сповіщення прийде в стан, який можна виконати.

дивіться цей приклад:

демонстрація станів потоку.

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