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. 

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

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

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.