1. Accueil
  2. Tutoriels
  3. Java

Gestion des Thread

Dernière mise à jour le par cs_Julien39 .

Généralités

Définition

Un thread est un processus en cours d'exécution. Lorsque la JVM démarre, la méthode main créé un Thread principal qui est exécuté puis d'autres Thread peuvent être gérés en parallèle de ce thread principal.

Cycle de vie

Un processus peut être :

  • Créé si celui ci a été instancié mais n'a pas été démarré
  • Actif une fois que la méthode start() a été appelée
  • Terminé dès que tout le code de la méthode run() a été exécuté
  • Bloqué si le Thread est en attente d'un évenement (fichier au synchronisation avec un autre Tread)

Le schéma suivant illustre ce cycle de vie :

Création d'un Thread

Il y a deux manières équivalentes de créer un Thread.

Hériter de la classe Thread

La première méthode consiste à créer une classe qui hérite de Thread et de redéfinir la méthode run(). Voici un exemple d'un Thread qui affiche un nombre et l'incrémente toutes les secondes :

public class Compteur extends Thread {
        
        @Override
        public void run(){
                for(int i=0; i<50; i++){
                        System.out.println(i);
                        try {
                                Thread.sleep(1000);
                        }
                        catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }
        
        public static void main(String[] args){
                new Compteur().start();
        }
}

Implémenter Runnable

La seconde méthode consiste à implémenter la méthode run() et à créer un Tread qui prend en argument une instance de la classe créée. Voici le même exemple écrit de cette manière

public class Compteur implements Runnable {
        
        @Override
        public void run(){
                for(int i=0; i<50; i++){
                        System.out.println(i);
                        try {
                                Thread.sleep(1000);
                        }
                        catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }
        
        public static void main(String[] args){
                new Thread(new Compteur()).start();
        }
}

Démarrage du Thread

Pour démarrer le Thread, on peut appeler sa méthode run() dans ce cas, la méthode run() est exécutée dans le Thread principal, dans ce cas, le Thread n'a pas vraiment d'intérêt.

La méthode start() permet de démarrer les opérations décrites dans la méthode run() dans un nouveau Thread en parallèle du thread courant.

En reprennant l'exemple précédent :

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

Ce code permet d'exécuter deux comptages dans la console qui affiche alors :

0
0
1
1
etc.

Méthodes associées à un thread

Méthode Description
start() Exécute le Thread
join() Permet d'attendre que le thread soit terminé pour continuer
join(long delaiGarde) Permet d'attendre que le thread courant soit terminé ou que le délai de garde soit dépassé pour continuer
wait() Permet d'attendre que le thread courant appelle la méthode notify() ou notifyAll() pour continuer
notify() Indique au Thread courant qu'il peut continuer son exécution s'il a été interrompu par la méthode wait()

Attendre la fin de l'exécution d'un Thread

Pour attendre la fin de l'exécution d'un Thread, on utilise la méthode join()
Dans le code, la méthode thread1.join() permet d'attendre que le thread thread1 soit terminé pour poursuivre l'exécution.

Voici un exemple d'utilisation de cette méthode :

public class Compteur implements Runnable {
        
        @Override
        public void run(){
                for(int i=0; i<3; i++){
                        System.out.println(i);
                        try {
                                Thread.sleep(1000);
                        }
                        catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
        }
        
        public static void main(String[] args){
                Thread t1=new Thread(new Compteur());
                Thread t2=new Thread(new Compteur());
                t1.start();
                try {
                        t1.join();
                }
                catch (InterruptedException e) {
                        e.printStackTrace();
                }
                t2.start();
        }
}
A voir également
Ce document intitulé « Gestion des Thread » issu de CodeS SourceS (codes-sources.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.