UM fio em Java pode existir em qualquer um dos seguintes estados a qualquer momento. Um thread está em apenas um dos estados mostrados em qualquer instante:

1. Novo Estado
2. Estado executável
3. Estado bloqueado
4. Estado de espera
5. Estado de espera cronometrado
6. Estado encerrado

O diagrama abaixo representa vários estados de um thread em qualquer instante:

Ciclo de vida de um thread 

Existem vários estados do thread em um ciclo de vida, conforme mencionado abaixo:

1. Novo tópico: Quando um novo thread é criado, ele está no novo estado . O thread ainda não começou a ser executado quando está neste estado. Quando um thread está no novo estado, seu código ainda não foi executado e não começou a ser executado.
2. Estado executável : Um tópico que é pronto para correr é movido para um estado executável. Nesse estado, um thread pode estar realmente em execução ou pronto para ser executado a qualquer momento. É responsabilidade do agendador de thread dar tempo para a execução do thread. Um programa multithread aloca um período fixo de tempo para cada thread individual. Cada thread leva um pequeno tempo para ser executado. Depois de um tempo de execução, um thread faz uma pausa e desiste da CPU para que outros threads possam ser executados.
3. Bloqueado: O thread estará no estado bloqueado quando está tentando adquirir um bloqueio mas atualmente o bloqueio é adquirido pelo outro thread. O thread passará do estado bloqueado para o estado executável quando adquirir o bloqueio.
4. Estado de espera : O thread estará em estado de espera quando chama wait() método ou juntar() método. Ele passará para o estado executável quando outro thread for notificado ou esse thread for encerrado.
5. Espera cronometrada : Um thread está em um estado de espera cronometrado quando chama um método com um parâmetro de tempo limite . Um thread permanece nesse estado até que o tempo limite seja concluído ou até que uma notificação seja recebida. Por exemplo, quando um thread chama sleep ou uma espera condicional, ele é movido para um estado de espera cronometrado.
6. Estado encerrado: Um encadeamento é encerrado devido a um dos seguintes motivos: 
   
   • Porque sai normalmente. Isso acontece quando o código do thread foi totalmente executado pelo programa.
   • Porque ocorreu algum evento errôneo incomum, como uma falha de segmentação ou uma exceção não tratada.

Estados de thread em Java

Em Java, para obter o estado atual do thread, use Thread.getState() método para obter o estado atual do thread. Java fornece java.lang.Thread.State enum que define as constantes ENUM para o estado de um thread, cujo resumo é fornecido abaixo: 

1. Novo 

Estado do thread para um thread que ainda não foi iniciado. 

chamar função javascript de html

público estático final Thread.State NOVO

2. Executável 

Estado do thread para um thread executável. Um thread no estado executável está em execução na máquina virtual Java, mas pode estar aguardando outros recursos do sistema operacional, como um processador. 

público estático final Thread.State RUNNABLE

3. Bloqueado 

Estado do thread para um thread bloqueado aguardando um bloqueio de monitor. Um thread no estado bloqueado está aguardando um bloqueio de monitor para inserir um bloco/método sincronizado ou reinserir um bloco/método sincronizado após chamar Objeto.wait(). 

Ridhima Tiwari

público estático final Thread.State BLOQUEADO

4. Esperando 

 Estado do thread para um thread em espera. Um thread está em estado de espera devido à chamada de um dos seguintes métodos: 

• Object.wait sem tempo limite
• Thread.join sem tempo limite
• LockSupport.parque

público estático final Thread.State ESPERANDO

5. Espera cronometrada 

Estado do thread para um thread em espera com um tempo de espera especificado. Um thread está no estado de espera cronometrado devido à chamada de um dos seguintes métodos com um tempo de espera positivo especificado: 

• Thread.sleep
• Object.wait com tempo limite
• Thread.join com tempo limite
• LockSupport.parkNanos
• LockSupport.parkUntil

público estático final Thread.State TIMED_WAITING

6. Rescindido 

Estado do thread para um thread encerrado. O thread concluiu a execução. 

público estático final Thread.State TERMINADO

Exemplo de demonstração de estados de thread

Abaixo está um exemplo real de um sistema de reserva de bilhetes que demonstra diferentes estados de thread:

Exemplo:

// Java program to demonstrate thread states  // using a ticket booking scenario class TicketBooking implements Runnable {  @Override  public void run() {    try {    // Timed waiting  Thread.sleep(200);   } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println('State of bookingThread while mainThread is waiting: ' +  TicketSystem.mainThread.getState());  try {    // Another timed waiting  Thread.sleep(100);   } catch (InterruptedException e) {  e.printStackTrace();  }  } } public class TicketSystem implements Runnable {  public static Thread mainThread;  public static TicketSystem ticketSystem;  @Override  public void run() {  TicketBooking booking = new TicketBooking();  Thread bookingThread = new Thread(booking);  System.out.println('State after creating bookingThread: ' + bookingThread.getState());  bookingThread.start();  System.out.println('State after starting bookingThread: ' + bookingThread.getState());  try {  Thread.sleep(100);  } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println('State after sleeping bookingThread: ' + bookingThread.getState());  try {    // Moves mainThread to waiting state  bookingThread.join();   } catch (InterruptedException e) {  e.printStackTrace();  }  System.out.println('State after bookingThread finishes: ' + bookingThread.getState());  }  public static void main(String[] args) {  ticketSystem = new TicketSystem();  mainThread = new Thread(ticketSystem);  System.out.println('State after creating mainThread: ' + mainThread.getState());  mainThread.start();  System.out.println('State after starting mainThread: ' + mainThread.getState());  } } 

conectar banco de dados java

Saída:

Explicação:

• Quando um novo thread é criado, o thread está no estado NOVO. Quando o método start() é chamado em um thread, o agendador de threads o move para o estado Runnable.
• Sempre que o método join() é chamado em uma instância de thread, o thread principal vai para Aguardando a conclusão do thread de reserva.
• Depois que o método run do thread for concluído, seu estado se tornará Terminado.