Exercice (Multi-threading)
Garantir un état cohérent de la ressource.
Le problème des lecteurs/rédacteurs
Plusieurs lecteurs peuvent y accéder en même
Ressource partagée temps.
L’accès pour les rédacteurs est un accès
exclusif si un rédacteur travaille avec la
ressource aucune autre entité
(lecteur+rédacteur) ne doit accéder a celle-ci.
Vérifier la Synchronisation lors de l’utilisation
de la ressource partagée (zone de fichier ou
zone de mémoire).
QUESTIONS :
1. Proposer une solution au problème des lecteurs/rédacteurs en utilisant le multi-threading:
Créer une classe RessourceParagée
Ecrire 4 méthodes : debut_lecture, fin_lecture, debut_ecriture, fin_ecriture. Ces
méthodes sont appelées par les threads lecteurs et rédacteurs avant et après un accès en
lecture ou en écriture à la ressource. Ces méthodes doivent garantir aussi les
synchronisations nécessaires.
Dans la classe principale, instancier de nombreux threads dont certains vont lire
(appels à debut_lecture, fin_lecture) et d’autres vont écrire (appels à debut_ecriture,
fin_ecriture).
Placer les affichages (System.out.println) pour observer le déroulement de la
synchronisation
Montrer que certains threads sont endormis (est réveillé plus tard) lorsqu’ils essayent
d’accéder à la ressource alors qu’ils n’y ont pas droit.
2. Proposer des solutions aux variantes du problème des lecteurs/rédacteurs suivantes :
Un rédacteur ne pourra commencer à écrire que lorsqu’aucun lecteur ne sera présent (y
compris en attente) priorité aux lecteurs.
Un rédacteur demandant à écrire sera autorisé à le faire dès que tous les lecteurs et les
rédacteurs actuels auront fini leur section critique (aucun nouveau lecteur ne sera
admis si un rédacteur désire écrire)priorité aux rédacteurs.
Les lecteurs et les rédacteurs passent dans l’ordre de leur demande (si plusieurs
arrivent à la suite ils doivent passer par ordre).
3. En s’inspirant de la solution du problème des lecteurs/rédacteurs, proposer une solution du
problème des producteurs / consommateurs (en utilisant les threads).
4. Simuler un environnement parallèle avec 10 processus qui collaborent pour résoudre un
problème en utilisant une mémoire partagée, et gérer l’accès à cette mémoire (en lecture et
écriture).
