[clos]Code source java D' une probléme de sémaphore
Fermé
medmadsi
Messages postés1Date d'inscriptiondimanche 14 juillet 2013StatutMembreDernière intervention14 juillet 2013
-
14 juil. 2013 à 14:49
Twinuts
Messages postés5375Date d'inscriptiondimanche 4 mai 2003StatutModérateurDernière intervention14 juin 2023
-
14 juil. 2013 à 16:29
Monsieur j'ai vous en pris réponder moi plus tôt possible , j'ai besoin d'une coude source j'ai déja l' algorithme mais j’arrive pas à le convertir en java d'une problème de sémaphore voila le pseudo coude merci d'avence
1-
Un babouin qui se présente pour traverser doit d’abord passer par un processus de gestion.
Il formule sa demande. Soit elle est mise dans une file d’attente d’un sémaphore appelé gestion_est, soit elle est prise en compte directement si la ressource gestion_est est disponible.
P(gestion_est)
C’est tout de même un babouin de plus! il faut donc incrémenter le nombre de babouins (nb_babouin_est) dont les demandes ont été formulées.
nb_babouin_est ++
On doit tester s’il s’agit du premier babouin. Dans ce cas, il doit demander la ressource corde. Si c’est le premier, la variable nb_babouin_est sera égale à 1.
si nb_babouin_est == 1 alors P(corde)
La demande de la corde du premier babouin est dans la file d’attente du sémaphore corde. Il ne peut l’avoir que si la corde est libérée par l’ordre V(corde).
Dès que la corde est libérée, le premier babouin réquisitionne la corde; il ne la rendra que si tous les babouins de l’est traversent. Ces derniers n’ont pas besoin de demander la corde, ils peuvent traverser directement. Un babouin qui n’est pas de l’est ne peut traverser puisque la corde n’est pas rendue libre.
Les babouins de l’ouest doivent attendre!
Une fois un babouin est pris en compte, il doit immédiatement libérer la ressource gestion_est pour les autres babouins_est qui arrivent. il n’attendra pas la fin de sa traversée.
Mis à part le premier babouin, tous les babouins_est peuvent traverser sans se préoccuper de la ressource corde!
Néanmoins, il est important de noter que la ressource gestion_est détenue par le premier babouin ne peut être libérée que si ce dernier obtient la ressource corde. Tous les babouins_est sont dans ce cas en attente.
V(gestion_est)
traverser()
Mais il faut repérer la fin de traversée du dernier babouin pour libérer la ressource corde pour une autre vague de babouin (est ou ouest). Dans ce cas la file d’attente est forcément nulle.
On est tenté à écrire :
nb_babouin_est –-
si nb_babouin_est == 0 alors V(corde)
Cela voudrait dire qu’une fois un babouin a traversé, le nombre de babouins doit être décrémenté. Si on arrive à la valeur 0, ça sera forcément le dernier babouin; on doit donc rendre la corde.
Mais il se pose un problème :
Imaginons qu’à l’instant t le denier babouin est entrain de terminer sa traversée.
A cette même instant, un autre babouin_est prend la ressource gestion_est, il lit la variable nb_babouin qui est à 1 qui n’est pas encore incrémenté. Puis son processus est endormi par le système.
Ensuite, le dernier babouin rend la ressource corde après avoir décrémenté la variable nb_babouin_est qui est à 0. Admettons qu’ensuite un babouin ouest la saisi puis commence à traverser.
Au moment ou le processus endormis se réveille, la valeur nb_babouin est erronée et le babouin en question se met à traverser sans avoir besoin de la ressource corde puis qu’il ne se considère pas comme premier mais plutôt second. Il peut se trouver nez à nez avec le baboin ouest . On n’a pas l’air malin!
C’est pour ce type de problème qu’on va faire en sorte qu’après chaque arrivée de babouin, de rendre la ressource gestion_est occupée.Dans ce cas aucun babouin_est n’est pris en compte; il doit attendre. Une fois le test passé on rend la gestion_est libre, peut être pour un autre groupe de babouins de l’est ou encore un groupe de babouins de l’ouest.
P(gestion_est)
nb_babouin_est –-
si nb_babouin_est == 0 alors V(corde)
V(gestion_est)
Code d’en haut
P(gestion_est)
nb_babouin_est ++
si nb_babouin_est == 1 alors P(corde)
V(gestion_est)
traverser()
nb_babouin_est –-
si nb_babouin_est == 0 alors V(corde)
P(gestion_est)
nb_babouin_est –-
si nb_babouin_est == 0 alors V(corde)
V(gestion_est)
Il en est de même pour le sémaphore gestion_ouest.
2-
Jusqu’au là, nous ne sommes pas à l’abri de la famine car si des babouins sont engagés, il n’y a aucune garantie pour ceux de l’autre côté de passer un jour.
Pour remédier à cette dernière, il faut modifier l’algorithme en ajoutant un sémaphore ordre_arrivee autour du protocole d’entrée. C’est donc le système qui gère la file d’attente de ceux ayant demandé la ressource qui garantira le respect de l’ordre des demandes.
Le code est donc le suivant :
P(ordre_arrivée)
P(gestion_est)
nb_babouin_est ++
si nb_babouin_est == 1 alors
P(corde)
V(gestion_est)
V(ordre_arrivée)
traverser()
P(gestion_est)
nb_babouin_est --
si nb_babouin_est == 0 alors
V(corde)
V(gestion_est)
Dès qu’un babouin de l’Est ou de l’Ouest prend la ressource ordre, son processus s’exécute. Il la rend dès qu’il s’apprête à traverser juste après avoir rendu la ressource gestion. C’est le babouin suivant dans la file d’attente du sémaphore ordre_arrivée qui voit son processus s’exécuter; Il peut s’agir d’un babouin_est ou d’un babouin_ouest.
La famine est irradiée!
A voir également:
[clos]Code source java D' une probléme de sémaphore
