Chap Programmation Concurrentielle

Les Threads
Programmation
concurrentielle en JAVA
Pr. Mostafa Saadi 20/21
Programmation concurentielle en
JAVA
Introduction
 Un Thread est un processus qui peut s’exécuter en parallèle.
 Un Thread est un objet de la classe Thread.
 Le thread est lancé par la méthode start.
JAVA
Tâche d’un thread
Interface Runnable
OU
JAVA
Interface Runnable (2)
JAVA
Classe Thread
JAVA
Cycle de vie d’un thread
JAVA
Priorité entre les threads
JAVA
Attendre la fin d’exécution des threads
Join
JAVA
Attendre la fin d’exécution des threads
Join
JAVA
Thread : Runnable et Callable
Runnable
 Runnable est une interface fonctionnelle, elle peut être remplacée par une expression
lambda
 Exemple :
JAVA
Thread : Runnable et Callable
Callable
 Callable est très similaire à Runnable. C’est une interface fonctionnelle, elle peut être
remplacée par une expression lambda
 Un objet Runnable ne retourne pas de résultat tandis qu'un objet Callable retourne un résultat.
 Un objet Runnable ne peut pas lever une exception vérifiée tandis qu'un objet Callable peut
lever une exception.
 L'interface Runnable existe depuis Java 1.0 alors que Callable n'a été introduit que dans Java
1.5.
 Exemple :
JAVA
L’API : ExecutorService
Introduction
 ExecutorService est un interface définie dans l’API java.util.concurrency.
 Elle fournit une nouvelle façon de haut niveau pour la manipulation des thread.
 Ce n’est pas le développeur qui crée les threads mais l‘ExecutorService.
 ExecutorService gère le cycle de vie des threads créés.
 Executros est une Factory pour créer des instances de ExecutorService.
 A l‘inverse d‘un thread qui se termine une fois la tâche est réalisée, le service
ExecutorService ne s‘arrête pas implicitement, même si les tàches sont réalisées.
JAVA
La classe Future
Si l’on donne à un thread une tâche Callable, comment faire pour récupérer le résultat de
l'exécution d'un thread sachant qu'on ne sait pas à priori s'il a effectivement terminé son
traitement, s'il a levé une exception ou s'il a été suspendu ?
La classe Future permet d’exploiter le résultat d’un thread, elle contient deux méthodes
importantes dans ce contexte (plus d’autres) :
 Boolean isDone(), teste la terminaison d’un thread, retourne true si le thread a terminé,
a été annulé ou une exception a été levée.
 <T> get (), méthode blocante, après que le thread se termine, retourne le résultat retourné
par la methóde Callable.call
JAVA
Méthodes (1)
ExecutorService définit plusieurs méthodes, les plus importantes pour nous sont :
 void execute(Runnable command), exécute une tâche Runnable.
 <T> Future<T> submit(Callable<T> task), exécute une tâche Callable.
 Future<?> submit(Runnable task), exécute similaire à execute, mais retourne un

objet Future.
JAVA
Méthodes (2)
 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks),

exécute une collection de tâches Callable et retourne une liste d’objets Future relatifs aux
tâches exécutées.
 <T> T invokeAny(Collection<? extends Callable<T> > tasks), exécute une

collection de tâches Callable, dès qu’un thread se termine, les autres sont arrêtés et
lerésultat du premier est retourné sous la forme d’un objet Future.
 void shutdown(), permet d’arrêter le service ExecutorService.
JAVA
Méthodes (3)
JAVA
La factory Executors
ExecutorService étant une interface, comment faire pour en créer des instances ?
L’API concurrency propose une classe factory Executors, qui propose les méthodes suivantes :
 ExecutorService Executors.newSingleThreadExecutor(), crée un seul thread pour

exécuter une ou plusieurs tâches mais dans l’ordre.
 ExecutorService Executors.newFixedThreadPool(int nbreThreads), crée un nombre

limité de thread pour effectuer les tâches. Les tâches sont mises dans une Queue et exécutées par
le thread qui est libre.
 ExecutorService Executors.newCachedThreadPool(), à chaque besoin, ce service crée

un nouveau thread, s’il y a un thread déjà créé et est disponible, on le réutilise.
JAVA
La factory Executors
 ScheduledExecutorService Executors.newSingleThreadScheduledExecutor(), crée

un seul thread qui sera lancé dans le future, soit une seule fois après une durée déterminée ou de
manière périodique..
 ScheduledExecutorService Executors.newScheduledThreadPool(int nbreThreads),

crée un pool de thrads qui seront lancés dans le future, soit une seule fois après une durée
déterminée ou de manière périodique..
JAVA
ExecutorService
Executors.newSingleThreadExecutor (1)
 Remarquez que le processus java ne s‘arrête pas, les executors doivent être arrêtés
explicitement
JAVA
ExecutorService
Executors.newSingleThreadExecutor (2)
 Remarquez que le processus java ne s‘arrête pas, les executors doivent être arrêtés
explicitement
JAVA
ExecutorService
Executors.newFixedThreadPool
JAVA
ExecutorService
Executors.newCachedThreadPool
JAVA
ExecutorService
Executors.newSingleThreadScheduledExecutor (1)
Nous permet de créer un unique thread qui pourra être démarré :
 Une fois après un délai donné « d » : schedule
 Après une délai initial, puis périodiquement après chaque durée « d » :

scheduleAtFixedRate
 Après une délai initial, puis périodiquement après chaque durée « d » calculée à partir de
la fin de l’exécution de la tâche précédente : ScheduleWithFixedDelay
JAVA
ExecutorService
La méthode schedule est identique à la méthode submit, avec l’option de décaler l’exécution.
Cette méthode s’applique aux Runnables et au Callables.
JAVA
ExecutorService
La méthode scheduleAtFixedRate permet de lancer une tâche de manière périodique. La
période entre les débuts des exécutions est la même.
JAVA
ExecutorService
La méthode scheduleWithFixedDelay permet de lancer une tâche de manière périodique. La
période entre le début d’exécution d’une tâche et la fin d’exécution de la tâche précedente est
est la même pour toutes les exécutions.
JAVA
La synchronisation des threads
Problème
Etant donné que les threads s’exécutent en parallèle, s’ils manipulent le même objet. Que se
passe-t-il ?
Exécutions :
Pourquoi les deux résultats ne se ressemblent pas ? Et pourquoi le résultat n’est pas 1 2 3 4 5 6
7 8 9 10 ?
JAVA
Solution, partie 1: Classes Atomiques (1)
Les opérateurs ++ et -- ne sont pas thread-safe, pourquoi ? Parce que ces opérateurs ne sont
pas atomiques.
Une opération est dite atomique si elle est exécutée comme étant une seule unité sans
interférence avec un autre thread.
L’API concurrency inclut un ensemble de classes atomiques
des méthodes spécifiques

Chaque classe contient
JAVA
Solution, partie 1: Classes Atomiques (2)
Avec la classe artomique, nous sommes sûr qu’aucune valeur ne sera sautée ou en double,
mais comme même l’ordre reste inconsistant.
Problème : l’incrénmentation se fait en atomique, mais les deux opérations d’incrémentation

et d’affichage non.
JAVA
Solution, partie 2: Synchronisation
Si un bloc est reférencé comme synchronisé, il n’est pas accessible par deux threads en
parallèle, le premier thread le verrouille via un Lock et ne le déverouille une fois qu’il termine
son exécution.
Si l’on souhaite synchroniser tout le corp d’une méthode, on peut définir la méthode comme
étant synchronized.
JAVA
Vecteur et ArrayList sont

deux classes qui sont
presque identiques, la
différence majeure entre
elles est que les méthodes
de Vecteur sont
synchronisées alors que
ArrayList non.
JAVA

Chap Programmation Concurrentielle

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chap Programmation Concurrentielle

Transféré par

Droits d'auteur :

Formats disponibles

Les Threads

 Un Thread est un processus qui peut s’exécuter en parallèle.

 Un Thread est un objet de la classe Thread.

 Le thread est lancé par la méthode start.

 Ce n’est pas le développeur qui crée les threads mais l‘ExecutorService.

 ExecutorService gère le cycle de vie des threads créés.

 Executros est une Factory pour créer des instances de ExecutorService.

 void execute(Runnable command), exécute une tâche Runnable.

 <T> Future<T> submit(Callable<T> task), exécute une tâche Callable.

 Future<?> submit(Runnable task), exécute similaire à execute, mais retourne un

 <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks),

 <T> T invokeAny(Collection<? extends Callable<T> > tasks), exécute une

 void shutdown(), permet d’arrêter le service ExecutorService.

 ExecutorService Executors.newSingleThreadExecutor(), crée un seul thread pour

 ExecutorService Executors.newFixedThreadPool(int nbreThreads), crée un nombre

 ExecutorService Executors.newCachedThreadPool(), à chaque besoin, ce service crée

 ScheduledExecutorService Executors.newSingleThreadScheduledExecutor(), crée

 ScheduledExecutorService Executors.newScheduledThreadPool(int nbreThreads),

Nous permet de créer un unique thread qui pourra être démarré :

 Une fois après un délai donné « d » : schedule

 Après une délai initial, puis périodiquement après chaque durée « d » :

L’API concurrency inclut un ensemble de classes atomiques

des méthodes spécifiques

Problème : l’incrénmentation se fait en atomique, mais les deux opérations d’incrémentation

Vecteur et ArrayList sont

Vous aimerez peut-être aussi