O fir în Java poate exista în oricare dintre următoarele stări la un moment dat. Un fir se află doar într-una dintre stările afișate în orice moment:

1. Stat nou
2. Stare rulabilă
3. Stat blocat
4. Starea de așteptare
5. Starea de așteptare temporizată
6. Stat terminat

Diagrama de mai jos reprezintă diferite stări ale unui fir în orice moment:

Ciclul de viață al unui fir 

Există mai multe stări ale firului într-un ciclu de viață, așa cum este menționat mai jos:

1. Subiect nou: Când se creează un fir nou, acesta se află în nou stat . Firul nu a început încă să ruleze când firul este în această stare. Când un fir se află în noua stare, codul său nu a fost încă rulat și nu a început să se execute.
2. Stare rulabilă : Un fir care este gata să alerge este mutat într-o stare rulabilă. În această stare, un fir de execuție ar putea rula de fapt sau ar putea fi gata să ruleze în orice moment. Este responsabilitatea programatorului de fire de a da timp firului de executie. Un program cu mai multe fire alocă o perioadă fixă ​​de timp fiecărui fir individual. Fiecare fir are o perioadă mică de timp pentru a rula. După ce rulează un timp, un thread se întrerupe și renunță la CPU, astfel încât alte fire să poată rula.
3. Blocat: Firul va fi în stare blocată când încearcă să dobândească o lacăt dar în prezent blocarea este dobândită de celălalt fir. Firul de execuție se va muta din starea blocată la starea rulabilă atunci când obține blocarea.
4. Starea de așteptare : Firul va fi în stare de așteptare când sună wait() metoda sau alăturați-vă () metodă. Se va muta în starea de rulat când alt fir va notifica sau acel thread va fi terminat.
5. Așteptare cronometrată : Un fir se află într-o stare de așteptare cronometrată când acesta apelează o metodă cu un parametru de time-out . Un fir de execuție se află în această stare până când expirarea este finalizată sau până când este primită o notificare. De exemplu, atunci când un fir apelează somn sau o așteptare condiționată, este mutat într-o stare de așteptare temporizată.
6. Stat terminat: Un thread se termină din oricare dintre următoarele motive: 
   
   • Pentru că iese normal. Acest lucru se întâmplă atunci când codul firului de execuție a fost executat în întregime de program.
   • Deoarece a avut loc un eveniment eronat neobișnuit, cum ar fi o eroare de segmentare sau o excepție netratată.

Stările firelor în Java

În Java pentru a obține starea curentă a firului de utilizare Thread.getState() metodă pentru a obține starea curentă a firului de execuție. Java oferă java.lang.Thread.State enum care definește constantele ENUM pentru starea unui fir, al cărui rezumat este prezentat mai jos: 

1. Nou 

Stare fir pentru un fir care nu a început încă. 

java deschiderea unui fișier

public static final Thread.State NOU

2. Rugabil 

Stare fir pentru un fir care poate fi rulat. Un fir de execuție în starea de rulare se execută în mașina virtuală Java, dar este posibil să aștepte alte resurse din sistemul de operare, cum ar fi un procesor. 

k algoritmul celui mai apropiat vecin

public static final Thread.State RUNNABLE

3. Blocat 

Starea firului de execuție pentru un fir de execuție blocat în așteptarea blocării monitorului. Un fir în starea blocată așteaptă ca o blocare a monitorului să intre într-un bloc/metodă sincronizat sau să reintră într-un bloc/metodă sincronizat după apelare Object.wait(). 

public static Final Thread.State BLOCAT

4. În așteptare 

 Stare fir pentru un fir în așteptare. Un fir de execuție este în stare de așteptare din cauza apelării uneia dintre următoarele metode: 

• Object.wait fără timeout
• Thread.join fără timeout
• LockSupport.park

public static final Thread.State ASTEPTARE

5. Așteptare cronometrată 

Starea firului de execuție pentru un fir de execuție în așteptare cu un timp de așteptare specificat. Un fir de execuție se află în starea de așteptare temporizată din cauza apelării uneia dintre următoarele metode cu un timp de așteptare pozitiv specificat: 

• Fire.somn
• Object.wait cu timeout
• Thread.join cu timeout
• LockSupport.parkNanos
• LockSupport.parkUntil

Thread final static public.Stare TIMED_WAITING

6. Terminat 

Stare fir pentru un fir terminat. Execuția firului a fost finalizată. 

public static final Thread.State TERMINAT

Exemplu de demonstrare a stărilor de fir

Mai jos este un exemplu real al unui sistem de rezervare a biletelor care demonstrează diferite stări ale firelor:

Exemplu:

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

avantajele si dezavantajele tehnologiei

Ieșire:

Explicaţie:

• Când este creat un fir nou, firul este în starea NOU. Când metoda start() este apelată pe un fir de execuție, planificatorul de fire îl mută în starea Runnable.
• Ori de câte ori metoda join() este apelată pe o instanță de fir, firul principal merge la Așteptați finalizarea firului de rezervare.
• Odată ce metoda de rulare a firului de execuție se termină, starea sa devine Terminată.