Diferença entre estados de thread WAIT e BLOCKED

Qual é a diferença entre o estado de thread WAIT e o estado de thread BLOCKED?

A documentação Thread.State :

Bloqueado
Um encadeamento que está bloqueado à espera de um bloqueio de monitor está neste estado.

Aguardando
Um encadeamento que está esperando indefinidamente por outro encadeamento para realizar uma ação específica está neste estado

não explica a diferença para mim.

Um thread vai para o estado de espera quando chama wait()um objeto. Isso é chamado de estado de espera . Uma vez que um thread atinge o estado de espera, ele precisará esperar até que algum outro thread chame notify()ou notifyAll()no objeto.

Assim que este tópico for notificado, ele não poderá ser executado. Pode ser que outros tópicos também sejam notificados (usando notifyAll()) ou o primeiro tópico não terminou seu trabalho, então ele ainda está bloqueado até ter sua chance. Isso é chamado de estado bloqueado . Um estado Blocked ocorrerá sempre que um thread tenta adquirir o bloqueio no objeto e algum outro thread já está segurando o bloqueio.

Uma vez que outros encadeamentos saíram e sua chance de encadeamento, ele se move para o estado Executável depois que é elegível para pegar o trabalho com base no mecanismo de encadeamento da JVM e se move para o estado de execução.

A diferença é relativamente simples.

No BLOCKEDestado, um thread está prestes a entrar em um synchronizedbloco, mas há outro thread em execução dentro de um synchronizedbloco no mesmo objeto. O primeiro thread deve então esperar que o segundo thread saia de seu bloco.

No WAITINGestado, um segmento está aguardando um sinal de outro segmento. Isso normalmente acontece por meio de uma chamada Object.wait(), ou Thread.join(). O encadeamento permanecerá neste estado até que outro encadeamento chame Object.notify()ou morra.

A diferença importante entre os estados de bloqueio e espera é o impacto no planejador. Um thread em um estado bloqueado está lutando por um bloqueio; esse thread ainda conta como algo que o planejador precisa atender, possivelmente sendo fatorado nas decisões do planejador sobre quanto tempo dar aos threads em execução (para que possa dar uma chance aos threads que bloqueiam o bloqueio).

Quando um thread está no estado de espera, o estresse que ele coloca no sistema é minimizado e o planejador não precisa se preocupar com isso. Ele fica inativo até receber uma notificação. Exceto pelo fato de que ele mantém um thread do sistema operacional ocupado, está totalmente fora de jogo.

É por isso que usar o notificar tudo é menos do que o ideal, ele faz com que um monte de threads que antes estavam adormecidos sem carga no sistema sejam ativados, onde a maioria deles irá bloquear até que possam adquirir o bloqueio, encontrar a condição em que estão esperar não é verdade e volte a esperar. Seria preferível notificar apenas os threads que têm chance de fazer progresso.

(Usar ReentrantLock em vez de bloqueios intrínsecos permite que você tenha várias condições para um bloqueio, para que você possa ter certeza de que o thread notificado está aguardando uma condição específica, evitando o bug de notificação perdida no caso de um thread sendo notificado por algo em que não pode agir.)

Perspectiva simplificada para interpretar despejos de thread:

• ESPERE - Estou esperando um trabalho, então estou ocioso agora.
  
• BLOQUEADO - Estou ocupado tentando fazer o trabalho, mas outro fio está no meu caminho, então estou ocioso agora.
  
• RUNNABLE ... (Native Method) - Chamei para RUN algum código nativo (que não terminou ainda), no que diz respeito ao JVM, você está RUNNABLE e ele não pode dar mais nenhuma informação. Um exemplo comum seria um método de ouvinte de soquete nativo codificado em C que está realmente esperando que qualquer tráfego chegue, então estou ocioso agora. Nessa situação, isso pode ser visto como um tipo especial de WAIT, já que não estamos realmente RUNNING (sem queima de CPU), mas você terá que usar um despejo de thread do SO em vez de um despejo de thread Java para vê-lo.

Blocked- Seu segmento está em estado executável do ciclo de vida do segmento e tentando obter bloqueio de objeto. Wait- Seu segmento está em estado de espera do ciclo de vida do segmento e aguardando o sinal de notificação para entrar no estado executável do segmento.

veja este exemplo:

demonstração dos estados dos fios.

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