Solution série n°4 (Synchronisation) 2021-2022
Exercice 1
1) Non. Elle n’assure pas l’exclusion mutuelle.
Justification : dans le code d’entée en la section critique (SC), c’est seulement l’instruction de
contrôle «while (! Libre); » où un processus peut être bloqué (ne pas accéder en <SC>). Si le
scenario d’exécution suivant : (1), (1’), …etc. se produit alors chaque processus trouve la variable
« libre =1 » et accède à sa section critique, car chaque processus teste la variable «libre » avant
que l’instruction d’affectation « libre :=0 » ne soit exécutée par l’autre processus. Dans ce cas, P1
et P2 pourront se trouver les deux au même temps en <SC>.
2) Oui, une situation d’interblocage peut avoir lieu.
Justification : supposant que P2 est dans la <SC>. En quittant cette dernière, au lieu de remettre
« Libre = 1 », il remit «libre =0 » (4’). Dans ce cas, le P2 est en dehors de la <SC> et empêche P1
d’entrer en <SC> (1).
Exercice 2
On a besoin de 3 sémaphores pour la synchronisation des 3 processus: P3 avec P1, P1 avec P2 et P2
avec P3.
semaphore Sem1=1, /* Initialisé à 1 pour que P1 puisse faire la première exécution en premier */
Sem2=0, /* Initialisé à 0 pour empêcher p2 de commencer l’exécution*/
Sem3=0; /* Initialisé à 0 pour empêcher p3 de commencer l’exécution*/
Processus P1 :
{
while(TRUE) {
P (Sem1); /*P1 attend l’exécution de P3 à partir de la 2eme itération de la boucle, car le
sémaphore est initialisé à 1*/
printf("je suis le processus %d",1);
V (Sem2); } /*réveiller le processus P2*/
}
Processus P2 :
{
while(TRUE) {
P (Sem2); /*P2 attend l’exécution de P1 à partir de la 1eme itération de la boucle, car
le
sémaphore est initialisé à 0*/
printf("je suis le processus %d",2);
V (Sem3) ; } /*réveiller le processus P3*/
};
Processus P3 :
{ while(TRUE) {
P (Sem3); /*P3 attend l’exécution de P2 à partir de la 1eme itération de la boucle, car le
sémaphore est initialisé à 0*/
printf("je suis le processus %d",3);
V (Sem1);} /*réveiller le processus P1*/
1/2
Exercice 3
1) Cette solution assure-t-elle l’exclusion mutuelle ? Justifier votre réponse ?
Réponse : Oui, elle assure l’exclusion mutuelle (c.à.d. au plus un processus dans la section critique).
Explication :
a) Cas où un seul processus entre en SC:
- Si par exemple PA termine l’exécution du code d’entrée (P(S), P(S)) avant PB, il (PA) accède à la
<SC> /* il ne se bloque pas, puisque le sémaphore S est initialement à 2 passe à 1 puis à 0>=0*/ et
PB se bloque au niveau du premier P(S) /* S passe à = -1<0*/
- En quittant la SC, PA, exécute le code de sortie (V(S), V(S)) /* A la fin, la valeur du sémaphore est S
= 0*/ et libère le processus PB pour qu’il exécute sa <SC>.
- Si PA exécute P(S) une autre fois avant la sortie de PB, il et se bloque. /* S = -1*/
b) Cas où aucun processus n’entre en SC:
- Si PA vient de terminer l’exécution seulement du premier P(S) de son code d’entrée en SC /* S
passe de 2 à 1*/ mais, avant d’exécuter le deuxième P(S),
- PB exécute aussi le premier P(S) de son code d’entrée en <SC> /* S passe de 1 à 0>=0*/, puis, en
poursuivant l’exécution de leur code d’entrée en <SC>; aucun processus n’accède à la <SC>. /*
puisque le sémaphore S passe de 0 à-1<0 puis de -1 à -2<0*/
2) Cette solution assure-t-elle la progression (Pas d’interblocage) ? Justifier votre réponse.
Non, on peut avoir une situation d’interblocage. D’après la réponse précédente (b) « cas où
aucun processus n’entre en SC) »:
- Un des processus exécute le premier P(S) et se bloque. /*S passe de 0 à -1*/
- Un autre processus exécute aussi le premier P(S) et se bloque. /* S passe de -1 à -2*/
- Ainsi, chaque processus se bloque au niveau du code d’entrée en <S.C> c.à.d. en dehors de la
<S.C> et empêche l’autre processus d’accéder en sa <S.C>. Donc, un cas d’interblocage
3) Modifier cette solution pour remédier au problème soulevé (sans modifier l’initialisation du
sémaphore).
On enlève un P(mutex) et V(mutex) soit pour le processus P1 ou pour le processus P2.
Exemple : On enlève P(mutex) et V(mutex) pour le processus P1 (pareil c’est on les enlève pour P2).
Semaphoe mutex= 2;
P1() P2()
{ {
Lire (som1); Lire (som2);
P(mutex); P(mutex); P(mutex);
Vcompte= Vcompte-som1; Vcompte= Vcompte-som2;
V(mutex); V(mutex); V(mutex);
} }
2/2
