I Java finns alltid en tråd i något av följande tillstånd. Dessa tillstånd är:

1. Ny
2. Aktiva
3. Blockerad / väntar
4. Tidsinställd väntar
5. Avslutad

Förklaring av olika trådtillstånd

Ny: När en ny tråd skapas är den alltid i det nya tillståndet. För en tråd i det nya tillståndet har koden inte körts ännu och har därför inte börjat köras.

Aktiva: När en tråd anropar start()-metoden, flyttas den från det nya tillståndet till det aktiva tillståndet. Det aktiva tillståndet innehåller två tillstånd inom sig: ett är körbar , och den andra är löpning .

Körbar:En tråd som är redo att köras flyttas sedan till körbart tillstånd. I det körbara tillståndet kan tråden vara igång eller vara redo att köras när som helst. Det är trådschemaläggarens plikt att tillhandahålla trådtiden att köra, dvs. flytta tråden till löptillståndet.
Ett program som implementerar multithreading får en fast tidsperiod för varje enskild tråd. Varje tråd körs under en kort tidsperiod och när den tilldelade tidsdelen är över, ger tråden frivilligt upp CPU:n till den andra tråden, så att de andra trådarna också kan köras under sin tid. Närhelst ett sådant scenario inträffar, ligger alla de trådar som är villiga att köra och väntar på att deras tur ska köras i körbart tillstånd. I körbart tillstånd finns det en kö där trådarna ligger.Löpning:När tråden får CPU:n flyttas den från körbart till körbart tillstånd. I allmänhet är den vanligaste förändringen i tillståndet för en tråd från körbar till körbar och igen tillbaka till körbar.

Blockerad eller väntar: Närhelst en tråd är inaktiv under en tid (inte permanent) är antingen tråden i blockerat tillstånd eller i vänteläge.

Till exempel kan en tråd (låt oss säga att den heter A) vilja skriva ut en del data från skrivaren. Men samtidigt använder den andra tråden (låt oss säga att den heter B) skrivaren för att skriva ut en del data. Därför måste tråd A vänta på att tråd B ska använda skrivaren. Således är tråd A i blockerat tillstånd. En tråd i det blockerade tillståndet kan inte utföra någon exekvering och förbrukar således aldrig någon cykel hos den centrala bearbetningsenheten (CPU). Därför kan vi säga att tråd A förblir inaktiv tills trådschemaläggaren återaktiverar tråd A, som är i väntande eller blockerat tillstånd.

När huvudtråden anropar join()-metoden sägs det att huvudtråden är i vänteläge. Huvudtråden väntar sedan på att de underordnade trådarna ska slutföra sina uppgifter. När de underordnade trådarna slutfört sitt jobb skickas ett meddelande till huvudtråden som återigen flyttar tråden från väntande till aktivt läge.

Om det finns många trådar i väntande eller blockerat tillstånd, är det trådplanerarens skyldighet att bestämma vilken tråd som ska väljas och vilken som ska avvisas, och den valda tråden ges då möjlighet att köras.

Tidsinställd väntan: Ibland leder väntan till svält. Till exempel har en tråd (dess namn är A) gått in i den kritiska delen av en kod och är inte villig att lämna den kritiska delen. I ett sådant scenario måste en annan tråd (dess namn är B) vänta för evigt, vilket leder till svält. För att undvika ett sådant scenario ges ett tidsbestämt vänteläge till tråd B. Således ligger tråden i vänteläge under en viss tidsperiod och inte för alltid. Ett verkligt exempel på tidsinställd väntan är när vi anropar sleep()-metoden på en specifik tråd. Metoden sleep() sätter tråden i det tidsinställda vänteläget. När tiden har gått ut vaknar tråden och börjar köras från när den har lämnat tidigare.

Avslutad: En tråd når avslutningsstatus på grund av följande skäl:

• När en tråd har avslutat sitt jobb, existerar eller avslutas den normalt.
Onormal uppsägning:Det inträffar när några ovanliga händelser som ett obehandlat undantag eller segmenteringsfel.

En avbruten tråd betyder att tråden inte längre finns i systemet. Med andra ord, tråden är död, och det finns inget sätt man kan återskapa (aktiv efter död) den döda tråden.

Följande diagram visar de olika tillstånden som är involverade i en tråds livscykel.

Implementering av trådstater

I Java kan man få det aktuella tillståndet för en tråd med hjälp av Thread.getState() metod. De java.lang.Thread.State klass av Java tillhandahåller konstanterna ENUM för att representera tillståndet för en tråd. Dessa konstanter är:

inkapsling java

 public static final Thread.State NEW 

Det representerar det första tillståndet i en tråd som är det NYA tillståndet.

 public static final Thread.State RUNNABLE 

Det representerar det körbara tillståndet. Det betyder att en tråd väntar i kön för att köras.

 public static final Thread.State BLOCKED 

Det representerar det blockerade tillståndet. I detta tillstånd väntar tråden på att skaffa ett lås.

 public static final Thread.State WAITING 

Det representerar vänttillståndet. En tråd kommer att gå till detta tillstånd när den anropar metoden Object.wait() eller metoden Thread.join() utan timeout. En tråd i vänteläge väntar på att en annan tråd ska slutföra sin uppgift.

 public static final Thread.State TIMED_WAITING 

Det representerar det tidsinställda väntetillståndet. Den största skillnaden mellan väntan och tidsbestämd väntan är tidsbegränsningen. Väntan har ingen tidsbegränsning, medan tidsbestämd väntan har tidsbegränsningen. En tråd som anropar följande metod når det tidsinställda vänteläget.

• sova
• gå med med timeout
• vänta med timeout
• parkera tills
• parkNanos

 public static final Thread.State TERMINATED 

Det representerar det slutliga tillståndet för en tråd som är avslutad eller död. En avslutad tråd betyder att den har slutfört sin körning.

Java-program för att demonstrera trådtillstånd

Följande Java-program visar några av tillstånden för en tråd definierad ovan.

Filnamn: ThreadState.java

 // ABC class implements the interface Runnable class ABC implements Runnable { public void run() { // try-catch block try { // moving thread t2 to the state timed waiting Thread.sleep(100); } catch (InterruptedException ie) { ie.printStackTrace(); } System.out.println('The state of thread t1 while it invoked the method join() on thread t2 -'+ ThreadState.t1.getState()); // try-catch block try { Thread.sleep(200); } catch (InterruptedException ie) { ie.printStackTrace(); } } } // ThreadState class implements the interface Runnable public class ThreadState implements Runnable { public static Thread t1; public static ThreadState obj; // main method public static void main(String argvs[]) { // creating an object of the class ThreadState obj = new ThreadState(); t1 = new Thread(obj); // thread t1 is spawned // The thread t1 is currently in the NEW state. System.out.println('The state of thread t1 after spawning it - ' + t1.getState()); // invoking the start() method on // the thread t1 t1.start(); // thread t1 is moved to the Runnable state System.out.println('The state of thread t1 after invoking the method start() on it - ' + t1.getState()); } public void run() { ABC myObj = new ABC(); Thread t2 = new Thread(myObj); // thread t2 is created and is currently in the NEW state. System.out.println('The state of thread t2 after spawning it - '+ t2.getState()); t2.start(); // thread t2 is moved to the runnable state System.out.println('the state of thread t2 after calling the method start() on it - ' + t2.getState()); // try-catch block for the smooth flow of the program try { // moving the thread t1 to the state timed waiting Thread.sleep(200); } catch (InterruptedException ie) { ie.printStackTrace(); } System.out.println('The state of thread t2 after invoking the method sleep() on it - '+ t2.getState() ); // try-catch block for the smooth flow of the program try { // waiting for thread t2 to complete its execution t2.join(); } catch (InterruptedException ie) { ie.printStackTrace(); } System.out.println('The state of thread t2 when it has completed it's execution - ' + t2.getState()); } } 

Produktion:

 The state of thread t1 after spawning it - NEW The state of thread t1 after invoking the method start() on it - RUNNABLE The state of thread t2 after spawning it - NEW the state of thread t2 after calling the method start() on it - RUNNABLE The state of thread t1 while it invoked the method join() on thread t2 -TIMED_WAITING The state of thread t2 after invoking the method sleep() on it - TIMED_WAITING The state of thread t2 when it has completed it's execution - TERMINATED 

Förklaring: Varje gång vi skapar en ny tråd, når den tråden det nya tillståndet. När metoden start() anropas på en tråd, flyttar trådschemaläggaren den tråden till det körbara tillståndet. Närhelst join()-metoden anropas på en trådinstans, måste den aktuella tråden som exekverar den satsen vänta på att den här tråden slutför sin exekvering, d.v.s. flytta den tråden till det avslutade tillståndet. Därför, innan den slutliga utskriftssatsen skrivs ut på konsolen, anropar programmet metoden join() på tråden t2, vilket gör att tråden t1 väntar medan tråden t2 avslutar sin exekvering och därmed hamnar tråden t2 till det avslutade eller döda tillståndet . Tråden t1 går till vänteläget eftersom den väntar på att tråden t2 ska avsluta sin exekvering eftersom den har anropat metoden join() på tråden t2.