UN fil en Java peut exister dans l’un des états suivants à tout moment. Un thread se trouve uniquement dans l'un des états affichés à tout instant :

1. Nouvel État
2. État exécutable
3. État bloqué
4. État d'attente
5. État d'attente temporisé
6. État terminé

Le diagramme ci-dessous représente les différents états d'un thread à tout instant :

Cycle de vie d'un fil 

Il existe plusieurs états du thread dans un cycle de vie, comme mentionné ci-dessous :

1. Nouveau fil de discussion : Lorsqu'un nouveau fil est créé, il se trouve dans le nouvel état . Le thread n'a pas encore commencé à s'exécuter lorsqu'il est dans cet état. Lorsqu'un thread se trouve dans le nouvel état, son code n'a pas encore été exécuté et n'a pas commencé à s'exécuter.
2. État exécutable : Un fil qui est prêt à courir est déplacé vers un état exécutable. Dans cet état, un thread peut être en cours d'exécution ou prêt à s'exécuter à tout instant. Il est de la responsabilité du planificateur de thread de donner au thread le temps de s'exécuter. Un programme multithread alloue une durée fixe à chaque thread individuel. Chaque thread dispose d'un peu de temps pour s'exécuter. Après avoir fonctionné pendant un certain temps, un thread fait une pause et abandonne le processeur afin que d'autres threads puissent s'exécuter.
3. Bloqué: Le fil sera dans l'état bloqué quand il essaie d'acquérir un verrou mais actuellement, le verrou est acquis par l'autre thread. Le thread passera de l’état bloqué à l’état exécutable lorsqu’il acquerra le verrou.
4. État d'attente  : le thread sera en état d'attente quand il appelle wait() méthode ou rejoindre() méthode. Il passera à l'état exécutable lorsqu'un autre thread le notifiera ou que ce thread sera terminé.
5. Attente chronométrée : Un thread se trouve dans un état d'attente temporisé lorsqu'il appelle une méthode avec un paramètre time-out . Un thread reste dans cet état jusqu'à ce que le délai d'attente soit écoulé ou jusqu'à ce qu'une notification soit reçue. Par exemple, lorsqu'un thread appelle sleep ou une attente conditionnelle, il est déplacé vers un état d'attente temporisé.
6. État terminé : Un fil de discussion se termine pour l'une des raisons suivantes : 
   
   • Parce que ça sort normalement. Cela se produit lorsque le code du thread a été entièrement exécuté par le programme.
   • Parce qu'un événement erroné inhabituel s'est produit, comme une erreur de segmentation ou une exception non gérée.

États de thread en Java

En Java pour obtenir l'état actuel de l'utilisation du thread Thread.getState() méthode pour obtenir l’état actuel du thread. Java fournit java.lang.Thread.State enum qui définit les constantes ENUM pour l'état d'un thread dont un résumé est donné ci-dessous : 

1. Nouveau 

État du thread pour un thread qui n’a pas encore démarré. 

public statique final Thread.State NOUVEAU

2. Exécutable 

État du thread pour un thread exécutable. Un thread à l'état exécutable s'exécute dans la machine virtuelle Java, mais il peut attendre d'autres ressources du système d'exploitation, telles qu'un processeur. 

public statique final Thread.State RUNNABLE

3. Bloqué 

État du thread pour un thread bloqué en attente d’un verrouillage du moniteur. Un thread à l'état bloqué attend un verrou du moniteur pour entrer dans un bloc/une méthode synchronisée ou entrer à nouveau dans un bloc/une méthode synchronisée après avoir appelé Objet.attendre(). 

public statique final Thread.State BLOQUÉ

4. Attendre 

 État du thread pour un thread en attente. Un thread est à l'état d'attente en raison de l'appel de l'une des méthodes suivantes : 

• Object.wait sans délai d'attente
• Discussion.join sans délai d'attente
• LockSupport.park

public statique final Thread.State EN ATTENTE

5. Attente chronométrée 

État du thread pour un thread en attente avec un temps d'attente spécifié. Un thread est dans l'état d'attente temporisé en raison de l'appel de l'une des méthodes suivantes avec un temps d'attente positif spécifié : 

• Sujet.sleep
• Object.wait avec délai d'attente
• Thread.join avec délai d'attente
• LockSupport.parkNanos
• LockSupport.parkUntil

public statique final Thread.State TIMED_WAITING

6. Résilié 

État du thread pour un thread terminé. Le thread a terminé son exécution. 

public static final Thread.State TERMINÉ

Exemple de démonstration des états de thread

Vous trouverez ci-dessous un exemple concret d'un système de réservation de billets qui illustre différents états de fil de discussion :

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

Sortir:

Explication:

• Lorsqu'un nouveau thread est créé, le thread est dans l'état NEW. Lorsque la méthode start() est appelée sur un thread, le planificateur de thread le déplace vers l'état Runnable.
• Chaque fois que la méthode join() est appelée sur une instance de thread, le thread principal passe en attente de la fin du thread de réservation.
• Une fois que la méthode run du thread est terminée, son état devient Terminé.