1- Threads

1 Thread

2 Interface Runnable

3 Interruption de Thread

Un processeur exécute une tâche à la fois, l'exécution multi-tâches est une construction des systèmes d'exploitation (les premiers ne l'étaient pas) : différentes tâches se succèdent constamment sur le processeur. Donc plusieurs threads se succèdent en même temps sur le processeur. Un processus est appellé un thread. Donc la machine exécute plusieurs threads en même temps, on parle de mutli-threading. Un programme java est un thread. Java supporte le multi-threading : on peut avoir plusieurs threads qui tournent en même temps pour un seul programme.

Pour créer des Thread, on peut soit créer des classes qui héritent de la classe Thread, soit des classes qui implémente l'interface Runnable (Thread est une classe qui implémente elle-même Runnable).

Un premier exemple : TestTh.java

run lance le processus, sleep(x) suspend l'exécution pour x millisecondes. En exécutant cet algorithme, on constate que les affichages sont mélangés et non pas exécutés linéairement. sleep est une méthode qui force la suspension d'exécution, dans le cas de la machine, l'OS gère les processus : le temps de téléchargement, le jeu sur le buffer de la carte graphique, de la carte réseau peuvent induire le passage d'un processus à un autre etc...

Ici, il y a quatre threads : les trois définis et le programme appellant. Si on appelait directement la méthode run des objets threads, la méthode run du premier s'exécuterait, la méthode run du second s'éxecuterait ensuite, puis la méthode du troisième, chacune induisant ses temps d'attente successivement. Le programme serait donc beaucoup plus long à exécuter. L'intérêt de pouvoir créer des programmes avec plusieurs threads apparaît donc lorsque on veut créer des tâches à réaliser simultanément. La méthode start ne peut être appellée qu'une fois, plusieurs appels lance : IllegalTrheadStateException. sleep est une méthode static de Thread qui suspend le Thread courant, Thread.sleep(x) aurait été equivalent. Sans mettre de sleep, on pourra avoir exécution intégrale d'un Thread éventuellement.

Pour pouvoir créer des Threads sur des classes qui héritent d'autres classes, on implemente l'interface Runnable. Celle-ci induit d'implémentée une méthode : run, il est toujours possible de faire appel à Thread.sleep(x). La technique consiste alors à créer des objets thread qui récupèrent en attribut des objets Runnable et les lance. L'exemple est modifié : TestTh2.java



Il est possible d'améliorer encore la démarche en simplifiant la création, pour chaque objet qui implémente l'interface Runnable, on peut développer une méthode start() :

public class ProcessusEcriture implements Runnable()
{
...

public void run()
	{	
	}

public void start()
	{
	Thread t=new Thread(this);
	t.start();
	}
...
}

run
{
...
	if(interrupted)
	{
	...
	return;//fin du thread
	}
}