Wilfreid K. AGBO et Grégoire J. MONEYENGONO - Java thread

Les Threads Java
Wilfreid K. AGBO
Grégoire J. MONEYENGONO
Université Djillali - FSE
Département d’Informatique
Ingénierie des Systèmes d’Information (I.S.I.)
15 février 2017
Wilfreid K. AGBO Grégoire J. MONEYENGONO (UDL) Java Thread 15 février 2017 1 / 39

Plan
1 Introduction
2 Déﬁnition et intérêts des Threads
3 Création des Threads
4 Propriétés et méthodes d’un Thread
5 Cycle de vie d’un thread
6 Interruption et Synchronisation des Threads
7 Conclusion

Introduction
Les threads sont omniprésents dans les programmes java. La JVM (Java
Virtual Machine), qui se charge d’exécuter nos programmes, crée des
threads à notre insu : les threads qui s’occupent des opérations de
nettoyage de la mémoire (Garbage Collector) et le thread d’exécution
principal de nos programme (main) font parti des nombreux exemples.
Nous essayerons de présenter les threads et leurs diﬀérentes propriétés.

Déﬁnition et intérêts des Threads
Rappel sur la notion de processus
De manière générale, un processus est un programme en cours
d’exécution. Un processus peut être dans diﬀérents états :
en exécution : le processus s’exécute sur un processeur du système.
Prêt : le processus est prêt à s’exécuter maintenant par le processeur
(occupé par un autre processus en exécution)
Bloqué : il manque une ressource (en plus du processeur) au
processus pour qu’il puisse s’exécuter.
A un processus est associé un ensemble de ressources propres à lui
comme :l’espace mémoire, le temps CPU, . . .

Notion de Thread
Un Thread est un processus léger à l’intérieur d’un autre processus
C’est une portion de code capable de s’exécuter en parallèle à
d’autres traitements
Remarque
Un Thread n’est pas un processus , en eﬀet les processus vivent dans des
espaces virtuels isolés alors que les Threads sont des traitements qui
vivent ensemble au sein d’un même processus.

Notion de Thread
Les Threads issus d’un même processus partagent les
ressources(temps CPU, memoire,. . .) allouées à celui-ci
Un processus peut posséder plusieurs
Threads(multi-Threading :exécution concurrente à l’intérieur d’un
processus de plusieurs tâches)
Un processus possède au moins un Thread (qui exécute le
programme principal, habituellement la fonction) main
Chaque Thread possède son propre environnement d’exécution
(valeurs des registres du processeur), ainsi q’une pile (variables
locales).
Contrairement à une idée reçue, les Threads ne s’exécutent pas en
même temps, mais en temps partagé, c’est pour cela qu’il est
important pour un thread de laisser une chance aux autres de
s’exécuter.

Intérêts des Thread
Les Threads sont utiles pour :
gérer l’exécution de traitements longs sans bloquer les autres. Ex :
lancer des traitements qui tournent en tâche de fond comme la
coloration syntaxique des éditeurs, aﬃchage et gestion des
interactions dans une interface graphique.
exécuter plusieurs instances d’un même code simultanément pour
accélérer le traitement, pour les longs traitements n’utilisant pas les
mêmes ressources. Ex : répondre à plusieurs requête en même temps
dans un serveur
simuler le parallélisme nécessaire à certaines classes applications
exploiter la structure multi-processeurs des ordinateurs modernes

Java et les Threads
Les threads font partie intégrante du langage JAVA. Elles sont gérées grâce
à la classe Thread. JAVA déﬁnit son propre mécanisme de thread aﬁn de
permettre l’utilisation facile et portable des threads sur tous mes systèmes.

Création des Threads Java
Il existe 3 méthodes pour créer les threads en Java :
L’Heritage de la classe Thread
L’implémentation de l’interface Runnable
L’implémentation de lesinterfaces de la FrameWork Executor

Création des Threads
L’héritage de la classe Thread
Le moyen le plus simple de créer un Thread est d’hériter de la classe
Thread contenu dans le package java.lang. Ensuite, il faut redéﬁnir la
méthode run() de cette classe qui contiendra les instructions que votre
Thread devra exécuter. Les principaux constructeurs de la classe Thread
sont :
Principaux constructeurs
public Thread() ;
public Thread(Runnable runnable) ;
Pour lancer un Thread, on appelle la méthode start(), qui appelle la
méthode run() que nous avons redéﬁni.

Voici un exemple simple de création d’un Thread :
1 public class MonThread extends Thread{
2
3 private String texte ;
4 private int nb;
5
6 public MonThread (String texte, int nb)
7 {
8 this . texte = texte ;
9 this .nb = nb;
0 }
1 public void run ()
2 { for (int i=0 ; i<nb ; i++)
3 System.out. println (texte) ;
4 }
5 }

Création et lancement des threads
1 public class TestThread {
2
3 public static void main(String [] args) {
4
5 MonThread e1 = new MonThread ("Thread1",10) ;
6 MonThread e2 = new MonThread ("ttThread2",7) ;
7 MonThread e3 = new MonThread ("tttThread3",5) ;
8
9 e1. start ();
0 e2. start ();
1 e3. start ();
2 }
3 }

L’héritage de la classe Thread
Voici une capture d’écran d’un test de notre programme :

L’héritage de la classe Thread (Avantages et Inconvénients)
Nous venons de voir comment créer des threads à partir de la classe
Thread. Cette démarche à les avantage suivantes :
Autant d’objets que de threads (chaque thread ayant sa propre
identité)
Possibilité d’avoir plusieurs classe diﬀérentes qui dérivent de Thread
avec une méthode run() spéciﬁque à chacune
Cependant il présente un inconvénient : Les objets Thread ne peuvent pas
dériver d’autres classes que de Thread (puisque JAVA ne possède pas
d’héritage multiple). Pour créer des threads, on dispose d’une seconde
démarche basée non plus sur une classe dérivée de Thread mais
simplement sur une classe implémentant l’interface Runnable.

Comme dit plus haut la deuxième méthode consiste à implémenter
l’interface Runnable qui ne contient qu’une seule méthode : run(), qui
devra être redéfini afin de spécifier les instructions qui seront exécuter par
le thread. Par la suite on créera des objets de type Thread en utilisant le
deuxième constructeur de la dite classe, qui reçoit en argument un objet
implémentant l’interface Runnable

En transformant l’exemple précédent voici ce qu’on obtient :
1 public class MonThread implements Runnable{
3 private int nb;
4
5 public MonThread (String texte, int nb) {
7 this .nb = nb;
8 }
9
0 public void run (){
1 try{
2 for (int i=0 ; i<nb ; i++)
4 }catch(InterruptedException e){}
5 }
6 }

2
4
5 MonThread e1 = new MonThread ("Thread1",10) ;
6 MonThread e2 = new MonThread ("ttThread2",7) ;
7 MonThread e3 = new MonThread ("tttThread3",5) ;
8
9 Thread t1 = new Thread(e1); t1.start ();
2 }
3 }

Remarque
On peut créer plusieurs threads diﬀérent sur un même objet Runnable.
Thread t1 = new Thread(e1) ;
Thread t2 = new Thread(e1) ;
L’avantage de cette méthode est que la classe peut hériter d’une autre
classe de son choix. Par exemple : JFrame

La FrameWork Executor
Ce framework contient un ensemble de classes qui permet de créer et
gérer un ensemble de threads (pool).
Ce framework nous met à disposition trois interfaces qui vous
permettent de travailler avec des implémentations de Runnable , de
Callable<V> ou des deux. Voici un diagramme de classes représentant
ces trois interfaces, leurs relations et leurs principales méthodes.

Framework Executor
Figure:

l’interface Executor : permet d’exécuter des implémentations de
l’interface Runnable uniquement ;
l’interface ExecutorService : permet d’exécuter des
implémentations des interfaces Runnable et Callable<V> ;
l’interface ScheduledExecutorService : permet d’exécuter des
implémentations des interfaces Runnable et Callable<V> avec la
possibilité de les planifier dans le temps ou de définir une périodicité
(pouvoir faire en sorte que les tâches se répètent).
Avantages
Ces interfaces permettent donc de gérer de façons différentes les
tâches à lancer de façon asynchrone.
On a le choix entre les implémentations de l’interface Runnable ou de
Callable<V> ,
mais aussi le choix entre lancer les tâches de façon différé ou de façon
cyclique. Et ce framework offre encore beaucoup d’autres
fonctionnalités.

Propriétés et méthodes des Threads
Propriétés des Threads - groupe de thread
Les threads utilisés dans le langage JAVA possède plusieurs propriétés
intéressantes :
Les groupes de Threads : Il est possible de créer des groupes
threads, qui pourront être arrêtés grâce à l’objet de type
ThreadGroup(String nameGroup)
Pour créer un thread d’un groupe de thread, on crée d’abord le groupe de
thread :
ThreadGroup monGroupe = new ThreadGroup ("Groupe Maitre") ;
Puis on utilise un constructeur qui prend en argument un groupe de thread
pour créer le thread en question.

Propriétés des Threads - groupe de thread
Runnable tache1 = new MonThread("Traitement1",5) ;
Runnable tache2 = new MonThread("Traitement2",10) ;
Thread t1 = new Thread (monGroupe,tache1) ;
Thread t2 = new Thread (monGroupe,tache2) ;
t1.start() ; t2.start() ;
Pour interrompre le traitement de tous les threads du groupe, on utilise la
méthode interrupt() de la classe ThreadGroup.
monGroupe.interrupt()

Propriétés des Threads - Priorités
Les threads JAVA ont une priorité, i.e. le gestionnaire de thread privilégiera
un thread à forte priorité plutôt qu’un autre pour le mettre en l’exécution.
JAVA gére 10 niveaux de priorité
allant de 1 (correspondant à la constante Thread.MIN_PRIORITY )
à 10 (correspondant à la constante Thread.MAX_PRIORITY )
en passant par 5 (correspondant à la constante
Thread.NORM_PRIORITY ).
Plus la priorité d’un thread est elevé plus il a de chance de passer dans
l’état RUNNABLE (execution).
On peut modiﬁer cette priorité via la méthode setPriority(int prio)

Propriétés des Threads - Priorités
Remarque
1 Par défaut un nouveau thread prend la priorité du thread qui l’a crée
2 Le niveau de priorité des threads dépend fortement du SE. JAVA en
gère 10 mais les SE n’en gèrent pas tous autant. Ainsi un thread
priorisé en JAVA peut avoir des priorités différentes selon le SE sur
lequel notre programme tourne.
Pour cette raison, il est fortement conseillé de ne pas modifier le
niveau de priorité des threads JAVA et de laisser le niveau par défaut
(Thread.NORM_PRIORITY )
En effet, si 2 threads de priorité différentes sont exécutés et
(fichier,variable)utilisent la même ressources ; Le thread de plus
grande priorité s’impose à celui de faible priorité. Ce qui pourrait
entrainer un problème dit de famine car la ressource est
constamment monopolisée par le thread a priorité haute.

Propriétés des Threads - Les démons( daemon thread)
Il s’agit d’un thread qui est supposé proposer un service général en tâche
de fond aussi longtemps que le programme tourne. Mais il n’est pas
l’essence du programme. Ainsi quand tous les threads non demons
s’achèvent, le programme se termine.
A l’inverse si des threads non démons tournent encore le rogramme ne se
termine pas.
Ex : La gestion des impressions, gestion de certaines tâches du SE, les
threads du ramasse-miette (garbage-collector) de la JVM sont des
démons.
Pour faire d’un thread un démon, on utilise la méthode setDaemon(true)
Pour savoir si un thread est un demon, on utilise la méthode isDaemon()
qui renvoie un boolean.

Propriétés des Threads - Les méthodes
La classe Thread fournit plusieurs méthodes pour gérer ses objets à
savoir :
Méthodes Rôles
Thread(Runnable t) Crée un nouveau thread devant exécuter
la méthode run()
void start() lance l’exécution du thread
(la JVM appelle la méthode run()
du thread)
void run() contient les traitements à exécuter
void setPriority(int prio) modiﬁe la priorité du thread
Table: Table

int getPriority() fournit la priotité du thread
void interrupt() demande l’interruption
du thread à la JVM run()
static Thread currentThread() fournit une référence
sur le thread courant
static void sleep(long n)() le thread est suspendu pour n ms
static int activeCount() renvoie le nb de thread du groupe
Table: Table

void join() attend la ﬁn de
l’exécution du thread
String toString() () fournit certains
caractéristiques du thread
boolean isAlive()() renvoie un boolean
qui indique le thread est actif ou non
Table: Table

Cycle de vie d’un thread
Les différents états
Un thread peut avoir plusieurs états et selon cet état il sera ou non traité
par le système. Ces états et leur code en JAVA sont :
Nouveau(NEW) : statut qu’il prend à sa création quand on fait new
Thread() : aucune ressource sytème ne lui est affecté et il n’est pas
encore démarré.
Exécutable (RUNNABLE) : il est en cours d’éxécution ; sa méthode
start a été invoqué.
Bloqué (BLOQUED, TIMED_WAIING,WAITING) :
WAITING : lorsqu’il attend indéfiniment un résultat.
TIME_WAITING : lorsqu’il est mis en pause via la méthode sleep()
BLOQUED : lorsqu’il tente d’accéder à une ressource (vérouillé) par
un autre thread.
Terminé(TERMINATED) : Etat qu’il prend lorqu’il a effectué
toutes ses tâches. On dit aussi qu’il est mort (on ne peut plus le
relancer par la méthode start())

Les diﬀérents états
Remarque
Sur une machine multi-processeur, la planniﬁcation pré-amptive n’est
utilisée que lorsque le nombre de thread excède le nombre de processeur.

Interruption et Synchronisation des Threads
Interruption
Par défaut l’interruption d’un thread s’arrête pour 2 raisons :
La ﬁn des traitements de la méthode run() est atteinte. Une
exception est levée durant le traitement de la méthode run()
Dans certains cas on peut avoir besoin d’interrompre un thread
prématurément depuis un autre thread. Pour ce faire, la classe
Thread dispose de la méthode interrupt() qui demande à
l’environnement de positionner un indicateur signalant une demande
d’arrêt du thread concerné.( Attention ! l’appel n’interrompt pas
directement le thread.)
Par ailleurs il est possible de connaitre l’état de cet indicateur à l’aide
de la méthode static interrupted()
Il existe aussi isInterrupted() qui renvoie aussi l’état du thread.

1 public class MonThread extends Thread{
3
4 public MonThread (String texte) {
6
7 }
8
0 try{
1 while(true){
2 if ( interrupted ()) return ;
4 sleep(5);
5 }
6 }catch(InterruptedException e){}
7 }
8 }

2
4
5 MonThread t1 = new MonThread ("Thread1") ;
6 MonThread t2 = new MonThread ("ttThread2") ;
7 MonThread t3 = new MonThread ("tttThread3") ;
8
9 t1. start (); t2. start (); t3. start ();
0 t1. interrupt ();
1 System.out. println ("Arret de t1");
2 t2. interrupt (); t3. interrupt ();
3 System.out. println ("Arret de t2 et t3");
4 }
5 }

Synchronisation
Problème : Comme dit plus haut, différents thread s’exécutant au sein
d’une application sont autorisés à accéder en lecture comme enécriture à
toutes les données présentes dans l’espace mémoire réservée par cette
application.
A cause de cette accès libre et de l’exécution concurrente des threads, il
peut arriver que 2 d’entre eux tentent d’accéder simultanément à une
même donnée(on parle de race condition). Les accès simultanés en
lecture sont inoffensifs, mais 2 problèmes fondamentaux surviennent lors
des accès simultanés en écriture.
Problème de visibilité : la modification apportée par un thread,
est-elle immédiatement visible par les autres threads ?
Problème de cohérence de données : Que se passe-t-il en cas de
modification concurrente ? les données ne risquent-t-elle pas d’être
corrompu ?

1 public class Nombres {
2
3 private int n = 100;
4
5 public void retrait (int c){
6
7 n = n − c;
8 System.out. println ("N = " + n);
9 }
0
1 public int getN(){
2
3 if (n<=0)
4 System.out. println ("C’est ﬁni ");
5 return n;
6 }
7
8 }

1 public class ThreadNombre extends Thread{
2
3 private Nombres nomb;
4 String nom;
5
6 public ThreadNombre (Nombres nomb, String nom){
7 this .nomb = nomb ;
8 this .nom = nom;
9 }
0
2 for(int i = 0; i <50; i++)
3 if (nomb.getN() > 0){
4 nomb.retrait(2);
5 System.out. println ("Retrait fait par " + nom);
6 }
7 }
8 }

1
2 public class Test {
3
5 // TODO Auto−generated method stub
6
7 Nombres nomb = new Nombres() ;
8 Thread t1 = new ThreadNombre (nomb, "thread1") ;
9 Thread t2 = new ThreadNombre (nomb, "thread2") ;
0 t1. start () ;
1 t2. start () ;
2 }
3 }

Synchronisation

Synchronisation
Sur l’exécution on observe des incohérences. Ceci est due au fait
l’ordonnanceur de JAVA place les threads en sommeil quand il le désire, et
lorsque le thread qui était en sommeil se réveille il reprend son travail là où
il l’avait laissé.
Pour résoudre ces problèmes, on a plusieurs manières :
Méthodes synchronisées : Il s’agit d’indiquer à la JVM q’un thread
est d’utiliser des données qu’un autre thread est susceptible d’altérer.
Ainsi, lorsque l’ordonnanceur met en sommeil un thread qui traitait
des données utilisables par un autre thread, ce premier traite garde la
priorité sur les données et tant qu’il n’a pas terminé son travail. Les
autres threads ne peuvent pas toucher : On parle de Synchronized
thread.

Synchronisation - Méthodes synchronisées
Pour cela il suﬃt d’ajouter dans la déclaration de notre méthode
retrait()le mot clé synchronized grâce auquel la méthode est inaccessible
à un thread si elle est déjà utilisée par un autre thread qui sera placé dans
une "liste d’attente"
public synchronized void retrait(int c){
n = n - c ;
System.out.println("N = " + n) ;
}

Synchronisation - Synchronisation temporelle
Verrou
A un instant donné une seule méthode peut donc accéder à un objet
donné. Pour cela chaque objet possède un jeton (un verrou) qui peut être
disponible ou pris. Un thread peut prendre le jeton d’un objet s’il est
disponible ou doit attendre sinon. Le verrou est attribué à la méthode
synchronisée appelée pour l’objet et il est restituer à la sortie de la
méthode. Tant que le verrou n’est pas restituer aucune autre méthode
synchronisée ne peut le recevoir.
Synchronisation temporelle : La classe Object possède les
méthodes wait() , notify() etnotifyAll(). Elles s’utilisent uniquement
que dans les méthodes synchronized
wait() :un thread est mis en attente sur cet cet objet.
notify() : réveille un thread en attente sur cet objet
notifyAll() : réveille tous les threads en attente sur cet objet.

Synchronisation-Synchronisation temporelle
L’interfarce Lock : Depuis Java 5, une nouvelle interface et un
nouvel objet ont été ajoutés au langage Java : il s’agit de l’interface
Lock et de l’objet ReentrantLock . Ces éléments permettent de
poser des verrous internes mais en aﬃnant leur gestion. L’interface
Lock est très simple car elle ne contient que deux méthodes
principales :
lock() : pose un verrou ;
unlock() : retire le verrou précédemment posé.

1 public class Nombres {
2 private int n = 100;
3
4 private Lock verrou = new ReentrantLock();
5 public void retrait (){
6
7 verrou.lock();
8
9 try{ n = n − c;
0
1 } ﬁnally {
2
3 verrou.unlock();
4 }
5 }
6 }

Synchronisation-Semaphore
Semaphore : ils permettent de mettre un verrou en fonction d’un
entier, celui-ci représentant un seuil d’acceptation d’utilisation d’une
ressource.
Ils possèdent un constructeur prenant un entier comme paramètre :
celui-ci sera la limite autorisée pour la ressource ; il possède aussi deux
méthodes
acquire() : opération de décrémentation atomique sur le compteur du
sémaphore ;
release() : opération d’incrémentation atomique sur le compteur du
sémaphore.
Ce sera donc via ces méthodes que nous allons réserver ou libérer une
ressource.

Conclusion
La programmation des threads n’est pas fondamentalement complexe,
mais nécessite une très bonne compréhension. Se lancer dans le
développement multithreads sans comprendre les mécanismes de ceux-ci
est un risque important.

Références
Bruce Eckel (2012)
Penser en Java
Valère VIANDIER (2004)
Programmation des threads en JAVA

Thanks !Any Question ?

Wilfreid K. AGBO et Grégoire J. MONEYENGONO - Java thread

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Wilfreid K. AGBO et Grégoire J. MONEYENGONO - Java thread

Similaire à Wilfreid K. AGBO et Grégoire J. MONEYENGONO - Java thread (20)

Plus de Wilfreid AGBO

Plus de Wilfreid AGBO (7)

Dernier

Dernier (20)

Wilfreid K. AGBO et Grégoire J. MONEYENGONO - Java thread