A szál Java-ban bármikor a következő állapotok bármelyikében létezhet. Egy szál minden pillanatban csak a bemutatott állapotok egyikében van:

1. Új állam
2. Futtatható állapot
3. Blokkolt állapot
4. Várakozó állam
5. Időzített várakozási állapot
6. Megszűnt állapot

Az alábbi diagram a szál különböző állapotait ábrázolja bármely pillanatban:

Egy szál életciklusa 

Az alábbiak szerint a szálnak több állapota van egy életciklusban:

1. Új téma: Amikor új szál jön létre, az a új állapot . A szál még nem indult el, amikor a szál ebben az állapotban van. Amikor egy szál új állapotban van, a kódja még nem fut le, és még nem indult el.
2. Futtatható állapot : Egy szál az futásra készen futtatható állapotba kerül. Ebben az állapotban egy szál ténylegesen fut, vagy bármikor futásra készen állhat. A szálütemező felelőssége, hogy időt adjon a szálnak a futásra. A többszálú program minden egyes szálhoz meghatározott időt rendel. Minden egyes szál futáshoz jut egy kis idő. Egy futás után egy szál szünetel, és feladja a CPU-t, hogy más szálak futhassanak.
3. Zárolt: A szál blokkolt állapotban lesz amikor zárat próbál szerezni de jelenleg a zárat a másik szál szerzi meg. A szál a blokkolt állapotból futtatható állapotba kerül, amikor megkapja a zárolást.
4. Várakozó állapot : A szál várakozási állapotban lesz amikor hív vár() módszer ill csatlakozik() módszer. Futtatható állapotba kerül, amikor egy másik szál értesít, vagy az adott szál megszakad.
5. Időzített várakozás : Egy szál időzített várakozási állapotban van, amikor időtúllépési paraméterrel rendelkező metódust hív meg . Egy szál addig van ebben az állapotban, amíg az időtúllépés be nem fejeződik, vagy amíg nem érkezik értesítés. Például amikor egy szál alvó állapotot vagy feltételes várakozást hív meg, az időzített várakozási állapotba kerül.
6. Megszűnt állapot: Egy szál a következő okok valamelyike ​​miatt szakad meg: 
   
   • Mert normálisan kilép. Ez akkor történik, ha a szál kódját a program teljesen végrehajtotta.
   • Mert szokatlan hibás esemény történt, például szegmentációs hiba vagy kezeletlen kivétel.

Szál állapotok Java nyelven

Java nyelven a szálhasználat aktuális állapotának lekéréséhez Thread.getState() módszer a szál aktuális állapotának megállapításához. Java biztosítja java.lang.Thread.State enum, amely meghatározza a szál állapotának ENUM-állandóit, amelynek összegzése az alábbiakban látható: 

1. Új 

Szálállapot egy olyan szálhoz, amely még nem indult el. 

az instagram előnyei személyes használatra

public static final Thread.State ÚJ

2. Futható 

Futható szál szálállapota. Egy futtatható állapotban lévő szál fut a Java virtuális gépen, de előfordulhat, hogy más erőforrásokra vár az operációs rendszertől, például egy processzorra. 

public static final Thread.State RUNNABLE

3. Blokkolt 

Szál állapota egy blokkolt szálhoz, amely a monitor zárolására vár. Egy blokkolt állapotban lévő szál arra vár, hogy a monitorzár belépjen egy szinkronizált blokkba/módszerbe, vagy a hívás után újra beírjon egy szinkronizált blokkot/módszert Object.wait(). 

public static final Thread.State BLOCKED

4. Várakozás 

 Szálállapot várakozó szálhoz. Egy szál várakozó állapotban van a következő metódusok valamelyikének meghívása miatt: 

• Object.wait időtúllépés nélkül
• Thread.join időkorlát nélkül
• LockSupport.park

public static final Thread.State WAITING

5. Időzített várakozás 

Szálállapot egy várakozó szálhoz meghatározott várakozási idővel. Egy szál időzített várakozási állapotban van, mivel a következő metódusok egyikét hívja meghatározott pozitív várakozási idővel: 

• Szál.alvás
• Object.wait időtúllépéssel
• Thread.join with timeout
• LockSupport.parkNanos
• LockSupport.parkUntil

public static final Thread.State TIMED_WAITING

nfa a dfa

6. Megszűnt 

Szálállapot egy lezárt szálhoz. A szál végrehajtása befejeződött. 

public static final Thread.State MEGSZÜNTETT

Példa a szálállapotok bemutatására

Az alábbiakban egy valós példa egy jegyfoglalási rendszerre, amely különböző szálállapotokat mutat be:

Példa:

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

hogyan lehet visszaadni a tömböt java-ban

Kimenet:

Magyarázat:

• Új szál létrehozásakor a szál ÚJ állapotba kerül. Amikor a start() metódust meghívjuk egy szálon, a szálütemező áthelyezi azt Futható állapotba.
• Amikor a join() metódus meghívásra kerül egy szálpéldányon, a főszál a Várakozás a foglalási szál befejezésére üzenetre kerül.
• Amint a szál futási metódusa befejeződik, állapota Terminated lesz.