JAVA

Les Threads
Terminologie

● Thread : fil en anglais, un thread est un fil

d’exécution.
● plusieurs traductions :
- activité,
- fil d’exécution,
- lightweight process (lwp) ou processus leger.

2
Intérêts:

● Simplifie la programmation dans de nombreux cas :

1. programmation événementielle.
2. I/O non bloquantes
3. servir plusieurs clients simultanément (serveur Web, BD, ...)
● Meilleure utilisation des capacités (CPU) :
- utilisation des temps morts

3
Introduction
● Les threads ou “processus légers” sont des unités d'exécution autonomes qui peuvent
effectuer des tâches, en parallèle avec d'autres thread.
● Le flot de contrôle d'un thread est séquentiel. Plusieurs threads peuvent être associés à
un “processus lourd”.
● En Java, le processus lourd est la JVM.
● Les threads coopèrent entre eux en échangeant des valeurs par la mémoire commune
(du processus lourd)
● Grâce au “multi-thread”, même sur une machine monoprocesseur, l'ordinateur donne
l'impression d'effectuer plusieurs tâches en parallèle.
Introduction

● Le noyau du système d'exploitation SE,

conserve en permanence le contrôle du
temps d'exécution en distribuant
cycliquement des tranches de temps à
chacune des applications A, B, C et D.
● Une application représente dans le système
un processus
Introduction

● chaque processus peut lui-même

fonctionner comme le système
d'exploitation en lançant des sous-tâches
internes au.
● Ces sous-tâches sont nommées Threads.
Ci-dessous nous supposons que
l'application D exécute en même temps les
3 Threads D1, D2 et D3
Introduction

● La commutation entre les threads d'un

processus fonctionne de le même façon que
la commutation entre les processus, chaque
thread se voit alloué cycliquement, lorsque le
processus D est exécuté une tranche de
temps.
● Le partage et la répartition du temps sont
effectués uniquement par le système
d'exploitation
Introduction

● Le système alloue le même temps d'exécution à

chaque processus
● Lorsque le tour vient au processus D de
s'exécuter dans sa tranche de temps, il
exécutera une sous-tranche pour D1, pour D2,
pour D3 et attendra le prochain cycle.
Introduction

● Lorsqu'un programme Java s'exécute le

processus associé comporte automatiquement
un thread appelé thread principal.
● les autre thread s'appellent des threads
secondaires.
Les Threads en Java

● En Java c'est l'interface Runnable qui permet l'utilisation des threads

● Cette interface est implantée par la classe Thread du package java.lang

● Java offre deux façons différentes pour définir un threads :

○ Soit par implémentation de l'interface Runnable.

○ Soit par héritage de la classe java.lang.Thread

La class Thread
● La classe Thread est définie dans le package java.lang. Elle implémente l'interface
Runnable .
● Elle possède plusieurs constructeurs :
○ Thread()
○ Thread(String name)
○ Thread(Runnable target)
○ Thread(ThreadGroup group, String name)
○ …
● Une fois créé, on peut configurer cet objet pour:
○ Lui associer une priorité
○ l'exécuter en invoquant sa méthode start() qui invoquer la méthode run()
○ ...La methode run() dans la class Thread est vide !!!
 Interface Runnable
● MyRunnable implémente l’interface Runnable

● Redéfinir la méthode run() dans MyRunnable .

1
2
 Interface Runnable
— Code Lanceur ( Main par exemple)

— Simulation

1
3
 Classe Thread
● Classe MyThread héritant de la classe Thread ( Thread implémente Runnable)

● Redéfinir la méthode run() dans MyRunnable

1
4
 Classe Thread
— Code Lanceur ( Main par exemple)

— Simulation

1
5
 Classe Anonyme
— tout est dans le Code Lanceur

Thread monThread = new Thread() {

public void run () {
...
}
}
monThread.start();

1
6
La class Thread
● Créer une instance de type Thread dont l'implémentation de la méthode run() va
contenir les traitements à exécuter.
La class Thread

● Et Si la classe Compte veut étendre

une autre classe et en faire une sous-
classe de Thread également?
L’interface Runnable
● Cette interface ne définit qu'une seule
méthode : void run().
● Dans les classes qui implémentent
cette interface, la méthode run() doit
être redéfinie pour contenir le code
des traitements qui seront exécutés
dans le thread.
L’interface Runnable vs la class Thread
● Il est préférable d'utiliser l'implémentation de Runnable car :
○ elle permet à la classe d'hériter au besoin d'une classe mère
○ elle permet une meilleure séparation des rôles
○ elle évite des erreurs car il suffit simplement d'implémenter la méthode run()
● Il est possible d'utiliser une instance de type Runnable pour plusieurs threads si
l'implémentation est thread-safe.
● Il ne faut pas invoquer la méthode run() d'un thread car les traitements seront exécutés
dans le thread courant mais ne seront pas exécutés dans un thread dédié.
Cycle de vie d’un Thread
Problème
Ecrire un programme pour calculer la somme de 1 à 10^6 à l’aide de plusieurs Thread.

1. Thread 1 : s1<- 1+2+...+500000

2. Thread 2: s2 <- 500001+...+10^6
3. Main Thread: s <- s1+s2

Comment récupérer s1 et s2 dans le Thread principale?

 Exercice
Nous vous proposons de programmer une simulation du
problème du robinet qui remplit d'eau une baignoire qui
fuit.

● débit du robinet est connu et paramétrable.

● La baignoire a une fuite dont le débit est connu et
paramétrable.
● Dès que la baignoire est entièrement vide on
colmate la fuite.
● On arrête le programme dès que la baignoire est
pleine que la fuite soit colmatée ou non.
Problème
Ecrire un programme pour calculer la somme de 1 à 10^6 à l’aide de plusieurs Thread.

1. Thread 1 : s1<- 1+2+...+500000

2. Thread 2: s2 <- 500001+...+10^6
3. Main Thread: s <- s1+s2

Comment récupérer s1 et s2 dans le Thread principale?

Problème de Ressources partagés
La variable de class SHARED_SUB_TOTAL sera accessible par tous les Threads Adder.
Problème

Que sera la valeur de SHARED_SUB_TOTAL?

Problème: data race conditions

Synchronized
Pour éviter le problème du race conditions on peut utiliser le mot cles synchronized au
niveau de:

● une methode d’objet:

○ public synchronized void maMethode()
● Une méthode de classe
○ public static synchronized void maMethode()
● Un block
○ public void maMethode() { ○ public static void maMethode() {
○ synchronized (this) { ○ synchronized (maClass.class) {
○ Inst1; ○ Inst1;
○ Inst2; ... ○ Inst2; ...
○ } ○ }
○ } ○ }
Synchronized
Callable & FutureTask
● La méthode run() de runnable ne renvoi pas de valeur.
● Le framework concurrency offre une solution: Callable & FutureTask.
● Callable:
○ java.util.concurrent.Callable
○ Interface Générique qui possède une seule méthode <T> call()
● FutureTask:
○ Constructor: FutureTask<T>(callable)
○ java.util.concurrent.FutureTask
○ Implement Runnable et Future
○ Possède la m”thode <T> get() pour récupérer le résultat de la méthode call() de callable
Callable
FutureTask
Problème

● Avec les méthodes précédentes, Pour chaque tâche il faut créer un nouveau Thread.
● La création d’un nouveau Thread est coûteuse => diminue les performances du
programme.
● Créer un nombre prédéfinie de Threads et réutiliser les thread existants.
ThreadPool & ExecutorService
ExecutorService

● ExecutorService crees un ensemble de Threads

● Envoyer des taches (runnable ou callable) à l’ExecutorService

● Recuperer les resultats des tâches sous forme de Future

ExecutorService
La classe Executors permet créer un ExecutorService avec differents types de
Thread Pool.

● Executors.newFixedThreadPool(int n)
○ Créer un ExecutorService avec un nombre fixe n de Threads et les garde toujour actives
○ S'ils sont tous occupés les tâches seront placé dans une file d’attente
● Executors.newCachedThreadPool()
○ Pour une nouvelle tâche Il utilise un Threads disponible sinon il crée un nouveau.
○ Si un Thread reste sans tache pour une période(une minute) il sera supprimé automatiquement.
● Executors.newSingleThreadExecutor()
○ Crée un seul Thread pour une exécution séquentielle de plusieur tâches.
ExecutorService