Gestion des Thread

Généralités
- Définition
- Cycle de vie
Création d'un Thread
- Hériter de la classe Thread
- Implémenter Runnable
Démarrage du Thread
Méthodes associées à un thread
Attendre la fin de l'exécution d'un Thread

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

Publié par cs_Julien39.

Connecter une application Android à une base de données

Traitement des images

Ajouter un commentaire