A fil en Java pot existir en qualsevol dels estats següents en un moment donat. Un fil només es troba en un dels estats mostrats en qualsevol moment:

1. Nou Estat
2. Estat executable
3. Estat bloquejat
4. Estat d'espera
5. Estat d'espera cronometrat
6. Estat acabat

El diagrama següent representa diversos estats d'un fil en qualsevol instant:

Cicle de vida d'un fil 

Hi ha diversos estats del fil en un cicle de vida, tal com s'esmenta a continuació:

1. Fil nou: Quan es crea un fil nou, es troba al fitxer nou estat . El fil encara no ha començat a executar-se quan el fil està en aquest estat. Quan un fil es troba en el nou estat, el seu codi encara no s'ha executat i no s'ha començat a executar.
2. Estat executable : Un fil que és llest per córrer es trasllada a un estat executable. En aquest estat, un fil pot estar en execució o pot estar llest per executar-se en qualsevol moment. És responsabilitat del planificador de fils donar temps al fil perquè s'executi. Un programa multifils assigna una quantitat fixa de temps a cada fil individual. Tots i cadascun dels fils tenen una petita quantitat de temps per executar-se. Després d'executar-se durant una estona, un fil s'atura i abandona la CPU perquè altres fils es puguin executar.
3. Bloquejat: El fil estarà en estat bloquejat quan està intentant adquirir un bloqueig però actualment el bloqueig l'adquireix l'altre fil. El fil passarà de l'estat bloquejat a l'estat executable quan adquireixi el bloqueig.
4. Estat d'espera : el fil estarà en estat d'espera quan crida wait() mètode o uneix-te () mètode. Passarà a l'estat d'execució quan un altre fil ho notificarà o s'acabarà.
5. Espera cronometrada : un fil es troba en un estat d'espera cronometrada quan es troba crida a un mètode amb un paràmetre de temps d'espera . Un fil es troba en aquest estat fins que s'ha completat el temps d'espera o fins que es rep una notificació. Per exemple, quan un fil crida a dormir o a una espera condicional, es mou a un estat d'espera cronometrada.
6. Estat acabat: Un fil s'acaba per qualsevol dels motius següents: 
   
   • Perquè surt amb normalitat. Això passa quan el codi del fil ha estat executat completament pel programa.
   • Perquè s'ha produït algun esdeveniment errònia inusual com un error de segmentació o una excepció no gestionada.

Estats del fil a Java

A Java per obtenir l'estat actual de l'ús del fil Thread.getState() mètode per obtenir l'estat actual del fil. Java proporciona java.lang.Thread.Estat enum que defineix les constants ENUM per a l'estat d'un fil com un resum del qual es mostra a continuació: 

1. Nou 

Estat del fil per a un fil que encara no ha començat. 

Força de neteja de la memòria cau npm

public static final Thread.State NOU

2. Es pot executar 

Estat del fil per a un fil executable. Un fil en estat executable s'està executant a la màquina virtual Java, però pot estar esperant altres recursos del sistema operatiu, com ara un processador. 

public static final Thread.State RUNNABLE

3. Bloquejat 

Estat del fil per a un fil bloquejat a l'espera d'un bloqueig del monitor. Un fil en estat bloquejat està esperant que un bloqueig de monitor entri en un bloc/mètode sincronitzat o torni a introduir un bloc/mètode sincronitzat després de trucar Object.wait(). 

public static final Thread.Estat BLOCKAT

4. Esperant 

 Estat del fil per a un fil en espera. Un fil està en estat d'espera a causa de la crida a un dels mètodes següents: 

• Object.wait sense temps d'espera
• Enfilar.unir-se sense temps d'espera
• LockSupport.park

public static final Fil.Estat ESPERANT

string java indexof

5. Espera cronometrada 

Estat del fil per a un fil en espera amb un temps d'espera especificat. Un fil es troba en l'estat d'espera cronometrada a causa de la crida a un dels mètodes següents amb un temps d'espera positiu especificat: 

• Fil.son
• Object.wait amb temps d'espera
• Thread.join amb temps d'espera
• LockSupport.parkNanos
• LockSupport.parkUntil

Fil final estàtic públic. Estat TIMED_WAITING

6. Finalitzat 

Estat del fil per a un fil finalitzat. El fil s'ha acabat d'executar. 

public static final Thread.Estat TERMINAT

Exemple de demostració d'estats de fil

A continuació es mostra un exemple real d'un sistema de reserva d'entrades que mostra diferents estats de fil:

Exemple:

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

convertir de char a int java

Sortida:

Explicació:

• Quan es crea un fil nou, el fil es troba a l'estat NOU. Quan es crida al mètode start() en un fil, el planificador de fils el mou a l'estat Runnable.
• Sempre que es crida el mètode join() en una instància del fil, el fil principal passa a Esperant que es completi el fil de reserva.
• Un cop finalitza el mètode d'execució del fil, el seu estat esdevé Terminat.