UN filo in Java può esistere in uno qualsiasi dei seguenti stati in un dato momento. Un thread si trova in ogni istante solo in uno degli stati mostrati:

1. Nuovo Stato
2. Stato eseguibile
3. Stato bloccato
4. Stato di attesa
5. Stato di attesa temporizzata
6. Stato terminato

Il diagramma seguente rappresenta i vari stati di un thread in qualsiasi istante:

Ciclo di vita di un thread 

Esistono più stati del thread in un ciclo di vita, come indicato di seguito:

1. Nuova discussione: Quando viene creato un nuovo thread, è nel file nuovo stato . L'esecuzione del thread non è ancora iniziata quando il thread è in questo stato. Quando un thread si trova nel nuovo stato, il suo codice deve ancora essere eseguito e l'esecuzione non è ancora iniziata.
2. Stato eseguibile : Un filo che è pronto per correre viene spostato in uno stato eseguibile. In questo stato un thread potrebbe essere effettivamente in esecuzione o potrebbe essere pronto per l'esecuzione in qualsiasi istante. È responsabilità dello scheduler del thread concedere al thread il tempo di essere eseguito. Un programma multi-thread assegna una quantità fissa di tempo a ogni singolo thread. Ogni thread ha una piccola quantità di tempo per essere eseguito. Dopo essere stato eseguito per un po', un thread si ferma e cede la CPU in modo che altri thread possano essere eseguiti.
3. Bloccato: Il thread sarà in stato bloccato quando tenta di acquisire un blocco ma attualmente il blocco viene acquisito dall'altro thread. Il thread passerà dallo stato bloccato allo stato eseguibile quando acquisisce il blocco.
4. Stato di attesa : il thread sarà in stato di attesa quando chiama wait() metodo o giuntura() metodo. Passerà allo stato eseguibile quando un altro thread avviserà o quel thread verrà terminato.
5. Attesa cronometrata : Un thread si trova in uno stato di attesa temporizzata quando chiama un metodo con un parametro di timeout . Un thread rimane in questo stato fino al completamento del timeout o fino alla ricezione di una notifica. Ad esempio, quando un thread chiama sleep o un'attesa condizionale viene spostato in uno stato di attesa temporizzata.
6. Stato terminato: Un thread termina per uno dei seguenti motivi: 
   
   • Perché esce normalmente. Ciò accade quando il codice del thread è stato interamente eseguito dal programma.
   • Perché si è verificato un evento errato insolito, come un errore di segmentazione o un'eccezione non gestita.

Stati dei thread in Java

In Java per ottenere lo stato corrente del thread utilizzare Thread.getState() metodo per ottenere lo stato corrente del thread. Java fornisce java.lang.Thread.State enum che definisce le costanti ENUM per lo stato di un thread il cui riepilogo è riportato di seguito: 

1. Nuovo 

Stato del thread per un thread che non è ancora iniziato. 

Java aprendo un file

Thread.State finale statico pubblico NUOVO

2. Percorribile 

Stato del thread per un thread eseguibile. Un thread nello stato eseguibile è in esecuzione nella Java virtual machine ma potrebbe essere in attesa di altre risorse dal sistema operativo come un processore. 

Thread.State finale statico pubblico RUNNABLE

decodifica javascript base64

3. Bloccato 

Stato del thread per un thread bloccato in attesa di un blocco del monitor. Un thread nello stato bloccato è in attesa che un blocco del monitor entri in un blocco/metodo sincronizzato o entri nuovamente in un blocco/metodo sincronizzato dopo la chiamata Oggetto.wait(). 

Thread finale statico pubblico. Stato BLOCCATO

4. In attesa 

 Stato del thread per un thread in attesa. Un thread è nello stato di attesa a causa della chiamata a uno dei seguenti metodi: 

• Object.wait senza timeout
• Thread.join senza timeout
• LockSupport.park

Thread.State finale statico pubblico in ATTESA

5. Attesa temporizzata 

Stato del thread per un thread in attesa con un tempo di attesa specificato. Un thread è nello stato di attesa temporizzata a causa della chiamata a uno dei seguenti metodi con un tempo di attesa positivo specificato: 

• Discussione.sonno
• Object.wait con timeout
• Thread.join con timeout
• LockSupport.parkNanos
• LockSupport.parkUntil

Thread.State finale statico pubblico TIMED_WAITING

6. Terminato 

Stato del thread per un thread terminato. Il thread ha completato l'esecuzione. 

Thread.State finale statico pubblico TERMINATO

Esempio di dimostrazione degli stati dei thread

Di seguito è riportato un esempio reale di un sistema di prenotazione di biglietti che mostra diversi stati del thread:

Esempio:

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

copertura delle dichiarazioni

Produzione:

Spiegazione:

• Quando viene creato un nuovo thread, il thread è nello stato NUOVO. Quando il metodo start() viene chiamato su un thread, lo scheduler del thread lo sposta nello stato Runnable.
• Ogni volta che il metodo join() viene chiamato su un'istanza del thread, il thread principale va in attesa del completamento del thread di prenotazione.
• Una volta completato il metodo run del thread, il suo stato diventa Terminato.