I Java eksisterer en tråd altid i en af ​​følgende tilstande. Disse stater er:

1. Ny
2. Aktiv
3. Blokeret / Venter
4. Tidsbestemt venter
5. Afsluttet

Forklaring af forskellige trådtilstande

Ny: Når en ny tråd oprettes, er den altid i den nye tilstand. For en tråd i den nye tilstand er koden ikke kørt endnu og er derfor ikke begyndt at udføre den.

Aktiv: Når en tråd kalder start()-metoden, flyttes den fra den nye tilstand til den aktive tilstand. Den aktive tilstand indeholder to tilstande i sig: den ene er kørebar , og den anden er løb .

Kørbar:En tråd, der er klar til at køre, flyttes derefter til den kørebare tilstand. I den kørebare tilstand kan tråden køre eller være klar til at køre på ethvert givet tidspunkt. Det er trådplanlæggerens pligt at give trådtiden til at køre, dvs. at flytte tråden til køretilstand.
Et program, der implementerer multithreading, erhverver et fast stykke tid til hver enkelt tråd. Hver eneste tråd løber i et kort tidsrum, og når det tildelte tidsudsnit er forbi, giver tråden frivilligt afkald på CPU'en til den anden tråd, så de andre tråde også kan køre i deres tid. Når et sådant scenarie opstår, ligger alle de tråde, der er villige til at køre og venter på deres tur til at køre, i kørebar tilstand. I kørebar tilstand er der en kø, hvor trådene ligger.Kører:Når tråden får CPU'en, flytter den sig fra kørebar til kørende tilstand. Generelt er den mest almindelige ændring i tilstanden af ​​en tråd fra kørebar til løbende og igen tilbage til kørebar.

Blokeret eller venter: Når en tråd er inaktiv i et tidsrum (ikke permanent), er tråden enten i blokeret tilstand eller i ventetilstand.

For eksempel kan en tråd (lad os sige dens navn er A) udskrive nogle data fra printeren. Men på samme tid bruger den anden tråd (lad os sige dens navn er B) printeren til at udskrive nogle data. Derfor skal tråd A vente på tråd B for at bruge printeren. Således er gevind A i blokeret tilstand. En tråd i blokeret tilstand er ude af stand til at udføre nogen udførelse og bruger derfor aldrig nogen cyklus af den centrale behandlingsenhed (CPU). Derfor kan vi sige, at tråd A forbliver inaktiv, indtil trådplanlæggeren genaktiverer tråd A, som er i ventende eller blokeret tilstand.

Når hovedtråden kalder join() metoden, siges det, at hovedtråden er i ventetilstand. Hovedtråden venter derefter på, at undertrådene fuldfører deres opgaver. Når undertrådene afslutter deres job, sendes en notifikation til hovedtråden, som igen flytter tråden fra at vente til den aktive tilstand.

Hvis der er mange tråde i ventende eller blokeret tilstand, så er det trådplanlæggerens pligt at bestemme hvilken tråd der skal vælges og hvilken der skal afvises, og den valgte tråd får så mulighed for at køre.

Tidsbestemt ventetid: Nogle gange fører ventetiden til sult. For eksempel er en tråd (dens navn er A) gået ind i den kritiske sektion af en kode og er ikke villig til at forlade den kritiske sektion. I et sådant scenarie skal en anden tråd (dens navn er B) vente for evigt, hvilket fører til sult. For at undgå et sådant scenarie gives en tidsindstillet ventetilstand til tråd B. Således ligger tråden i ventetilstanden i et bestemt tidsrum og ikke for evigt. Et rigtigt eksempel på tidsbestemt ventetid er, når vi kalder sleep()-metoden på en bestemt tråd. Sleep()-metoden sætter tråden i tidsindstillet ventetilstand. Når tiden er udløbet, vågner tråden og starter sin udførelse fra den er gået tidligere.

Afsluttet: En tråd når afslutningstilstanden på grund af følgende årsager:

• Når en tråd har afsluttet sit job, eksisterer den eller afsluttes normalt.
Unormal opsigelse:Det opstår, når nogle usædvanlige hændelser såsom en ubehandlet undtagelse eller segmenteringsfejl.

Et afsluttet gevind betyder, at gevindet ikke længere er i systemet. Med andre ord, tråden er død, og der er ingen måde, man kan genskabe (aktiv efter dræb) den døde tråd.

Følgende diagram viser de forskellige tilstande, der er involveret i en tråds livscyklus.

Implementering af trådstater

I Java kan man få den aktuelle tilstand af en tråd ved hjælp af Thread.getState() metode. Det java.lang.Thread.State klasse af Java giver konstanterne ENUM til at repræsentere tilstanden af ​​en tråd. Disse konstanter er:

Algoritme til binær søgning

 public static final Thread.State NEW 

Det repræsenterer den første tilstand af en tråd, der er den NYE tilstand.

 public static final Thread.State RUNNABLE 

Det repræsenterer den kørebare tilstand. Det betyder, at en tråd venter i køen på at køre.

 public static final Thread.State BLOCKED 

Det repræsenterer den blokerede tilstand. I denne tilstand venter tråden på at få en lås.

 public static final Thread.State WAITING 

Det repræsenterer ventetilstanden. En tråd vil gå til denne tilstand, når den kalder Object.wait()-metoden eller Thread.join()-metoden uden timeout. En tråd i ventetilstand venter på, at en anden tråd fuldfører sin opgave.

 public static final Thread.State TIMED_WAITING 

Det repræsenterer den tidsindstillede ventetilstand. Den største forskel mellem ventetid og tidsbestemt ventetid er tidsbegrænsningen. Ventetid har ingen tidsbegrænsning, hvorimod tidsbestemt ventetid har tidsbegrænsning. En tråd, der påberåber sig følgende metode, når den tidsindstillede ventetilstand.

• søvn
• deltage med timeout
• vent med timeout
• parker Indtil
• parkNanos

 public static final Thread.State TERMINATED 

Det repræsenterer den endelige tilstand af en tråd, der er afsluttet eller død. En afsluttet tråd betyder, at den har afsluttet sin udførelse.

Java-program til demonstration af trådtilstande

Det følgende Java-program viser nogle af tilstandene for en tråd defineret ovenfor.

Filnavn: 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 

Forklaring: Hver gang vi afføder en ny tråd, opnår denne tråd den nye tilstand. Når metoden start() kaldes på en tråd, flytter trådplanlæggeren denne tråd til den kørebare tilstand. Hver gang join()-metoden påkaldes på en trådforekomst, skal den aktuelle tråd, der udfører denne sætning, vente på, at denne tråd afslutter sin eksekvering, dvs. flytte tråden til den afsluttede tilstand. Derfor, før den endelige print-sætning udskrives på konsollen, påkalder programmet metoden join() på tråd t2, hvilket får tråden t1 til at vente, mens tråden t2 afslutter sin udførelse, og dermed kommer tråden t2 til den afsluttede eller døde tilstand. . Tråd t1 går til ventetilstand, fordi den venter på, at tråd t2 afslutter sin udførelse, da den har påkaldt metoden join() på tråd t2.