A Faden in Java kann jederzeit in einem der folgenden Zustände vorhanden sein. Ein Thread befindet sich zu jedem Zeitpunkt nur in einem der angezeigten Zustände:

1. Neuer Staat
2. Ausführbarer Zustand
3. Blockierter Zustand
4. Wartezustand
5. Zeitgesteuerter Wartezustand
6. Beendeter Zustand

Das folgende Diagramm stellt verschiedene Zustände eines Threads zu jedem Zeitpunkt dar:

Lebenszyklus eines Threads 

Es gibt mehrere Zustände des Threads in einem Lebenszyklus, wie unten erwähnt:

1. Neuer Thread: Wenn ein neuer Thread erstellt wird, befindet er sich im neuer Staat . Der Thread hat noch nicht mit der Ausführung begonnen, wenn er sich in diesem Zustand befindet. Wenn sich ein Thread im neuen Zustand befindet, muss sein Code noch ausgeführt werden und hat noch nicht mit der Ausführung begonnen.
2. Ausführbarer Zustand : Ein Thread also bereit zum Laufen wird in einen ausführbaren Zustand versetzt. In diesem Zustand kann ein Thread tatsächlich ausgeführt werden oder jederzeit zur Ausführung bereit sein. Es liegt in der Verantwortung des Thread-Schedulers, dem Thread Zeit zum Ausführen zu geben. Ein Multithread-Programm weist jedem einzelnen Thread eine feste Zeitmenge zu. Jeder einzelne Thread erhält eine kleine Zeitspanne zum Ausführen. Nachdem ein Thread eine Weile ausgeführt wurde, pausiert er und gibt die CPU frei, damit andere Threads ausgeführt werden können.
3. Gesperrt: Der Thread befindet sich im blockierten Zustand wenn versucht wird, eine Sperre zu erhalten aber derzeit wird die Sperre vom anderen Thread erworben. Der Thread wechselt vom blockierten Zustand in den ausführbaren Zustand, wenn er die Sperre erhält.
4. Wartezustand : Der Thread befindet sich im Wartezustand wenn es wait() aufruft Methode bzw verbinden() Verfahren. Es wechselt in den ausführbaren Zustand, wenn ein anderer Thread eine Benachrichtigung sendet oder dieser Thread beendet wird.
5. Zeitgesteuertes Warten : Ein Thread befindet sich in einem zeitgesteuerten Wartezustand, wenn er ruft eine Methode mit einem Timeout-Parameter auf . Ein Thread bleibt in diesem Zustand, bis das Timeout abgelaufen ist oder bis eine Benachrichtigung empfangen wird. Wenn ein Thread beispielsweise den Ruhezustand oder einen bedingten Wartezustand aufruft, wird er in einen zeitgesteuerten Wartezustand versetzt.
6. Beendeter Zustand: Ein Thread wird aus einem der folgenden Gründe beendet: 
   
   • Weil es normal beendet wird. Dies geschieht, wenn der Code des Threads vollständig vom Programm ausgeführt wurde.
   • Weil ein ungewöhnliches fehlerhaftes Ereignis wie ein Segmentierungsfehler oder eine nicht behandelte Ausnahme aufgetreten ist.

Thread-Zustände in Java

Verwenden Sie in Java den aktuellen Status des Threads Thread.getState() Methode, um den aktuellen Status des Threads abzurufen. Java bietet java.lang.Thread.State Enumeration, die die ENUM-Konstanten für den Status eines Threads definiert. Eine Zusammenfassung davon finden Sie unten: 

1. Neu 

Thread-Status für einen Thread, der noch nicht gestartet wurde. 

string ti int

öffentlicher statischer finaler Thread.State NEU

2. Lauffähig 

Thread-Status für einen ausführbaren Thread. Ein Thread im ausführbaren Zustand wird in der Java Virtual Machine ausgeführt, wartet jedoch möglicherweise auf andere Ressourcen vom Betriebssystem, beispielsweise einen Prozessor. 

öffentlicher statischer finaler Thread.State RUNNABLE

3. Blockiert 

Thread-Status für einen Thread, der blockiert ist und auf eine Monitorsperre wartet. Ein Thread im blockierten Zustand wartet auf eine Monitorsperre, um einen synchronisierten Block/eine synchronisierte Methode einzugeben oder nach dem Aufruf erneut einen synchronisierten Block/eine synchronisierte Methode einzugeben Object.wait(). 

öffentlicher statischer finaler Thread.State BLOCKIERT

4. Warten 

 Thread-Status für einen wartenden Thread. Ein Thread befindet sich aufgrund des Aufrufs einer der folgenden Methoden im Wartezustand: 

• Object.wait ohne Zeitüberschreitung
• Thread.join ohne Timeout
• LockSupport.park

öffentlicher statischer finaler Thread.State WAITING

5. Zeitgesteuertes Warten 

Thread-Status für einen wartenden Thread mit einer angegebenen Wartezeit. Ein Thread befindet sich im zeitgesteuerten Wartezustand, da eine der folgenden Methoden mit einer angegebenen positiven Wartezeit aufgerufen wird: 

Schnittstelle in Java

• Thread.sleep
• Object.wait mit Timeout
• Thread.join mit Timeout
• LockSupport.parkNanos
• LockSupport.parkUntil

öffentlicher statischer finaler Thread.State TIMED_WAITING

6. Beendet 

Thread-Status für einen beendeten Thread. Der Thread hat die Ausführung abgeschlossen. 

öffentlicher statischer finaler Thread.State TERMINATED

Beispiel für die Demonstration von Thread-Zuständen

Unten sehen Sie ein reales Beispiel eines Ticketbuchungssystems, das verschiedene Thread-Status demonstriert:

Beispiel:

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

Mylivecricket-Alternative

Ausgabe:

Erläuterung:

• Wenn ein neuer Thread erstellt wird, befindet sich der Thread im Status NEU. Wenn die Methode start() für einen Thread aufgerufen wird, versetzt ihn der Thread-Scheduler in den Status „Ausführbar“.
• Immer wenn die Methode „join()“ für eine Thread-Instanz aufgerufen wird, wechselt der Haupt-Thread zu „Warten auf den Abschluss des Buchungs-Threads“.
• Sobald die Ausführungsmethode des Threads abgeschlossen ist, ändert sich sein Status in „Beendet“.