logo

TechCodeview

Livssyklusen til en tråd (trådtilstander)

I Java eksisterer en tråd alltid i en av følgende tilstander. Disse statene er:

  1. Ny
  2. Aktiv
  3. Blokkert / venter
  4. Tidsbestemt venter
  5. Avsluttet

Forklaring av forskjellige trådtilstander

Ny: Når en ny tråd opprettes, er den alltid i den nye tilstanden. For en tråd i den nye tilstanden har koden ikke blitt kjørt ennå og har derfor ikke begynt å kjøre.

Aktiv: Når en tråd påkaller start()-metoden, flyttes den fra den nye tilstanden til den aktive tilstanden. Den aktive tilstanden inneholder to tilstander i den: en er kjørbar , og den andre er løping .

    Kjørbar:En tråd som er klar til å kjøre, flyttes deretter til kjørbar tilstand. I kjørbar tilstand kan tråden kjøre eller være klar til å kjøre på et gitt tidspunkt. Det er trådplanleggerens plikt å gi trådtiden til å løpe, dvs. flytte tråden til løpende tilstand.
    Et program som implementerer multithreading får en fast del av tiden til hver enkelt tråd. Hver eneste tråd løper i et kort tidsrom, og når den tildelte tidsdelen er over, gir tråden frivillig opp CPU-en til den andre tråden, slik at de andre trådene også kan kjøre i løpet av sin tid. Hver gang et slikt scenario inntreffer, ligger alle de trådene som er villige til å løpe og venter på at deres tur skal løpe, i kjørbar tilstand. I kjørbar tilstand er det en kø der trådene ligger.Løping:Når tråden får CPU-en, flytter den seg fra kjørbar til løpende tilstand. Generelt er den vanligste endringen i tilstanden til en tråd fra kjørbar til løper og igjen tilbake til løpbar.

Blokkert eller venter: Når en tråd er inaktiv i en periode (ikke permanent), er enten tråden i blokkert tilstand eller i ventetilstand.

For eksempel kan en tråd (la oss si at den heter A) ønsker å skrive ut noen data fra skriveren. Men samtidig bruker den andre tråden (la oss si at den heter B) skriveren til å skrive ut noen data. Derfor må tråd A vente på at tråd B skal bruke skriveren. Dermed er tråd A i blokkert tilstand. En tråd i blokkert tilstand er ikke i stand til å utføre noen kjøring og bruker derfor aldri noen syklus til den sentrale prosesseringsenheten (CPU). Derfor kan vi si at tråd A forblir inaktiv til trådplanleggeren reaktiverer tråd A, som er i ventende eller blokkert tilstand.

Når hovedtråden påkaller join()-metoden, sies det at hovedtråden er i ventetilstand. Hovedtråden venter deretter på at undertrådene skal fullføre oppgavene sine. Når undertrådene fullfører jobben, sendes et varsel til hovedtråden, som igjen flytter tråden fra ventende til aktiv tilstand.

Hvis det er mange tråder i ventende eller blokkert tilstand, er det trådplanleggerens plikt å bestemme hvilken tråd som skal velges og hvilken som skal avvises, og den valgte tråden får da muligheten til å kjøre.

Tidsbestemt venting: Noen ganger fører venting til sult. For eksempel har en tråd (navnet er A) gått inn i den kritiske delen av en kode og er ikke villig til å forlate den kritiske delen. I et slikt scenario må en annen tråd (navnet er B) vente for alltid, noe som fører til sult. For å unngå et slikt scenario, gis en tidsbestemt ventetilstand til tråd B. Dermed ligger tråden i ventetilstand for et spesifikt tidsrom, og ikke for alltid. Et ekte eksempel på tidsbestemt venting er når vi påkaller sleep()-metoden på en spesifikk tråd. Sleep()-metoden setter tråden i tidsbestemt ventetilstand. Etter at tiden er ute, våkner tråden og starter utføringen fra den har gått tidligere.

Avsluttet: En tråd når avslutningstilstanden på grunn av følgende årsaker:

  • Når en tråd har fullført jobben sin, eksisterer den eller avsluttes normalt.
    • Unormal oppsigelse:Det oppstår når noen uvanlige hendelser som et ubehandlet unntak eller segmenteringsfeil.

En terminert tråd betyr at tråden ikke lenger er i systemet. Med andre ord, tråden er død, og det er ingen måte man kan gjenopprette (aktiv etter drepe) den døde tråden.

Følgende diagram viser de forskjellige tilstandene som er involvert i livssyklusen til en tråd.

Java tråd livssyklus

Implementering av trådstater

I Java kan man få den nåværende tilstanden til en tråd ved å bruke Thread.getState() metode. De java.lang.Thread.State klasse av Java gir konstantene ENUM for å representere tilstanden til en tråd. Disse konstantene er:

shehzad poonawala 
 public static final Thread.State NEW

Den representerer den første tilstanden til en tråd som er den NYE tilstanden.

 public static final Thread.State RUNNABLE

Det representerer den kjørbare tilstanden. Det betyr at en tråd venter i køen for å kjøre.

 public static final Thread.State BLOCKED

Den representerer den blokkerte tilstanden. I denne tilstanden venter tråden på å få en lås.

 public static final Thread.State WAITING

Det representerer ventetilstanden. En tråd vil gå til denne tilstanden når den påkaller Object.wait()-metoden, eller Thread.join()-metoden uten tidsavbrudd. En tråd i ventetilstand venter på at en annen tråd skal fullføre oppgaven.

 public static final Thread.State TIMED_WAITING

Den representerer den tidsbestemte ventetilstanden. Hovedforskjellen mellom venting og tidsbestemt venting er tidsbegrensningen. Venting har ingen tidsbegrensning, mens tidsbestemt venting har tidsbegrensningen. En tråd som påkaller følgende metode når den tidsbestemte ventetilstanden.

  • sove
  • bli med med timeout
  • vent med timeout
  • parker til
  • parkNanos
 public static final Thread.State TERMINATED

Den representerer den endelige tilstanden til en tråd som er avsluttet eller død. En avsluttet tråd betyr at den er fullført.

Java-program for å demonstrere trådtilstander

Følgende Java-program viser noen av tilstandene til en tråd definert 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()); } }

Produksjon: 

 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 skaper en ny tråd, oppnår den den nye tilstanden. Når metoden start() påkalles på en tråd, flytter trådplanleggeren den tråden til den kjørbare tilstanden. Hver gang join()-metoden påkalles på en hvilken som helst trådforekomst, må den gjeldende tråden som kjører den setningen vente på at denne tråden fullfører utførelsen, dvs. flytte tråden til den avsluttede tilstanden. Derfor, før den endelige utskriftssetningen skrives ut på konsollen, påkaller programmet metoden join() på tråden t2, noe som får tråden t1 til å vente mens tråden t2 fullfører sin utførelse og dermed får tråden t2 til avsluttet eller død tilstand . Tråden t1 går til ventetilstand fordi den venter på at tråden t2 skal fullføre utføringen ettersom den har påkalt metoden join() på tråden t2.