Отладка-Thread.State: WAITING? Что это значит? [Дубликат]

см. этот пример:

демонстрация состояний потока.

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

Важным отличием между заблокированными и ожидающими состояниями является влияние на планировщик. Нить в заблокированном состоянии является частью waitset, борющейся за блокировку; этот поток по-прежнему считается чем-то, что планировщик должен обслуживать, возможно, принимая во внимание решения планировщика о том, сколько времени требуется для выполнения текущих потоков.

Когда поток находится в состоянии ожидания, стресс, который он накладывает на систему, сведен к минимуму, и планировщику не нужно беспокоиться об этом. Он неактивен, пока не получит уведомление.

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

(Использование ReentrantLock вместо встроенных блокировок позволяет вам иметь несколько условий для одной блокировки, так что вы можете удостовериться, что уведомленный поток - это тот, который ждет определенного условия, избегая ошибки с потерянным уведомлением в случай потока, уведомляемый о чем-то, на что он не может действовать.)

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

Отличие относительно просто.

В состоянии BLOCKED поток вот-вот войдет в блок synchronized, но есть еще один поток, текущий в рамках блока synchronized на тот же объект. Первый поток должен ждать, пока второй поток выйдет из своего блока.

В состоянии WAITING поток ожидает сигнала из другого потока. Обычно это происходит путем вызова Object.wait() или Thread.join(). Затем поток будет оставаться в этом состоянии, пока другой поток не вызовет Object.notify() или не умрет.

Упрощенная перспектива для интерпретации дампов потоков:

• WAIT - Я жду, чтобы мне дали какую-то работу, поэтому я сейчас простаиваю.
• BLOCKED - I «Я занят, пытаясь выполнить работу, но на моем пути стоит еще один поток, поэтому я сейчас простаиваю.
• RUNNABLE ... (Native Method) - я вызвал для RUN некоторый собственный код ( который еще не завершен), так как JVM обеспокоен, вы RUNNABLE, и он не может дать никакой дополнительной информации. Общим примером может быть собственный метод прослушивания сокетов, закодированный в C, который на самом деле ждет, пока какой-либо трафик не поступит, поэтому я сейчас простаиваю. В этой ситуации это можно рассматривать как особый вид WAIT, поскольку мы на самом деле не работаем (без процессора), но вам придется использовать дамп потока операционной системы, а не дамп потока Java, чтобы увидеть его.