Pages 1 | 2

Lors de notre première approche vers les threads en Java nous avions utilisé les deux méthodes existantes pour créer notre thread :

- L'instanciation d'une classe dérivée de la classe Thread.
- L'interface Runnable.

Enfin nous avions terminé cette introduction par un court programme, réunissant deux threads qui affichaient de manière non contrôlée une série de chiffres.

Afin de mieux comprendre pourquoi nous avions obtenu ce résultat, un passage théorique s'impose.

Le cycle de vie d'un thread

Ce cycle peut se résumer en quatre étapes :

- Création du thread, il est prêt
- En exécution (Runnable)
- En attente (Not Runnable)
- Mort

Voyons plus en détails comment se décomposent chacune de ces étapes.

En ce qui concerne la première étape, nous l'avons déjà abordé dans le tutoriel précédent :

(fichier threadTest.java)
public class threadTest extends Thread
{
     public void run()
     {
          for(int i = 1; i<= 10; i++)
               System.out.println(i + " " + getName());
     }

     public static void main (String[] args)
     {
          Thread t1 = new threadTest();
          t1.start();
     }
}

Les deux lignes à retenir ici sont celles en gras. La première crée en fait un objet "vide" pour lequel aucune ressource n'a encore été allouée.
C'est seulement lorsque la deuxième ligne est exécutée que des ressources lui sont attribuées. A partir de ce moment le thread va être planifié. Nous reviendrons sur cette notion.

La seconde étape : l'exécution. Le thread effectue (normalement) ce pour quoi il a été conçu, il est susceptible de quitter cet état pour diverses raisons. Nous en reparlerons lorsque nous détaillerons la planification.

Troisième étape : l'attente. Celle-ci peut être due à plusieurs facteurs.
La méthode sleep() en est un. Elle prend comme paramètres une durée en millisecondes assortie d'une durée facultative en nanosecondes au bout de laquelle le thread sort de son attente.
Autres facteurs, la méthode wait() (nous l'étudierons dans un autre tutoriel), ou le blocage dû à un traitement d'entrées / sorties. Le temps nécessaire pour venir à bout d'un tel type de traitement est très long comparé à celui consommé pour des instructions traditionnelles. En conséquence, un thread qui effectue une opération d'entrée / sortie est placé en état d'attente jusqu'à la fin du traitement, il repasse alors à l'état "prêt".

La mort du thread réprésente la quatrième et dernière étape de ce cycle de vie. Notez que les fonctions stop(), suspend() et resume(), sont "deprecated" et ne doivent plus être employées (risques d'instabilité : le lien donne plus de détails).
Comment alors arrêter un thread ? L'exemple suivant montre une voie possible :

public class threadTest extends Thread
{
     boolean kill_thread = false;
   
     public void run()
     {
          while (kill_thread == false)
               for(int i = 1; i<= 10; i++)
                    System.out.println(i + " " + getName());
     }

     public void stop_thread()
     {
          kill_thread = true;
     }
}

Voyons maintenant en quoi consiste le "scheduling".

Pages 1 | 2