Chapitre 4 : L’interblocag (DeadLock)

4.1 introduction
L’allocation d’une ressource à usage exclusif nécessite un verrouillage (lock en anglais). Dans
certaines situations, réaliser l’opération de verrouillage peut engendrer un blocage mortel du
processus qui verrouille. Le verrou (lock) devient mortel (dead). D’où le mot deadlock en anglais
qui est appelé interblocage en français.

Un processus a besoin d'un ensemble de ressources (mémoire, espace disque, fichier,

périphériques, ...) attribuées par le système d’exploitation. Le problème d'interblocage peut survenir,
si des processus détiennent des ressources et en demandent d’autres qui ne sont pas libres.

Exemple : Deux Processus P1 et P1 ont besoins de deux ressources critiques R1 et R2. Chaque
processus a besoins des deux ressources en même temps. Le processus P1 demande R1 puis R2 et
le processus P2 demande R2 puis R1.

• un processus P1 détient une ressource R1 et attend une autre ressource R2 qui est utilisée par
un autre processus P2 ;
• le processus P2 détient la ressource R2 et attend la ressource R1.
• On a une situation d’interblocage (P1 attend P2 et P2 attend P1). Les deux processus seront
bloqués indéfiniment.

Le graphe suivant, appelé graphe d’allocation des ressources, représente le scénario de L'
interblocage.

P1 P2
Alloué

Demande

R1 R2

Graphe d'allocation de ressources

Au niveau de code exécuté par les processus, l'interblocage se produit comme suit :
Après que le processus P1 exécute P(mutex1) , une interruption horloge se produit provoquant la
suspension de P1 et l'activation de P2. P2 exécute P(mutex2) sans se bloqué puis se bloque au
niveau de p(mutex1). Après activation de P1, il se bloque en exécutant P(mutex2). Donc P1 et P2
seront bloqués infiniment.

Processus P1:  Processus P2:
 P(Mutex1)  P(Mutex2)
 P(Mutex2)  P(Mutex1)
 /*utiliser  R1 et R2*/  /*utiliser  R1 et R2*/
 V(Mutex2)  V(Mutex1)
 V(Mutex1)  V(Mutex2)

Le code exécute par les processus P1 et P2

1
Un ensemble de processus est en interblocage si chaque processus attend la libération d’une
ressource allouée à un autre appartenant à l’ensemble. Comme tous les processus sont en attente,
aucun ne pourra s’exécuter et donc libérer les ressources demandées par les autres. Ils attendront
tous indéfiniment.

4.2 Quatre conditions necessaire de survenue d’un interblocage :

Les 4 conditions suivantes doivent être vérifiées en même temps.

1. Exclusion mutuelle : Chaque ressource est soit attribuée à un seul processus, soit
disponible Utilisation d’une ressource en exclusion mutuelle, donc dans une section de code
critique
2. Détention et attente : Les processus qui détiennent des ressources précédemment obtenues
peuvent en demander de nouvelles. Sections critiques imbriquées
3. Pas de réquisition : Les ressources obtenues par un processus ne peuvent lui être retirées
contre son gré. Leur libération doit être explicite. Libération exécutée dans le protocole de
sortie de SC
4. Attente circulaire : Il y a un cycle orienté d’au moins 2 processus, chacun attendant une
ressource détenue par un autre processus du cycle.

4.3 Traitement de l’interblocage

4.3.1 Détecter et guérir

une solution efficace mais brutale: tuer un ou plusieurs processus de l’ensemble de processus
interbloqués, ce qui permet de libérer les ressources.
Pour détecter les interblocages, le SE construit dynamiquement le graphe d’allocation des
ressources du système qui indique les attributions et les demandes de ressources. Le système vérifie
s’il y a des interblocages :
• A chaque modification du graphe suite à une demande d’une ressource.
• Périodiquement ou lorsque l’utilisation du processeur est inférieure à un certain seuil.

4.3.2 Stratégie d’évitement :

laisser aux processus faire ce qu’ils veulent, sauf qu’un contrôle (coûteux) est exécuté avant chaque
attribution de ressource. Cette technique utilise l’algorithme du banquier proposé par dijkstra en
1965. L’algorithme du banquier est théoriquement excellent mais pratiquement peu utile puisque il
suppose que le système connaît auparavant les besoins des processus en ressources ce qui n'est pas
possible dans la majorité des cas. Il y a peu de systèmes qui mettent en œuvre cet algorithme.

Algorithme du Banquier de dijkstra

Soit 5 processus (A,B,C,D et E) et Soit 4 types de ressources (R1, R2, R3 et R4) :
• 6 copies de R1 (5 sont déjà attribuées aux processus)
• 3 copies de R2 ( 3 sont déjà attribuées)
• 4 copies de R3 (2 sont déjà attribuées)
• 2 copies de R4 (2 sont déjà attribuées )
• Il reste disponible : 1 copie de R1, 0 copie de R2, 2 copies de R3 et 0 copies de R4.
Nous aurons 3 vecteurs
• vecteur des ressources existantes : E= [6 3 4 2 ].
• vecteur des ressources détenues :P= [5 3 2 2].
• vecteur des ressources disponibles :A= E – P = [1 0 2 0]

2
 R1 R2 R3 R4 R1 R2 R3 R4
A 3 0 1 1 A 1 1 0 0
B 0 1 0 0 B 0 1 1 2
C 1 1 1 0 C 3 1 0 0
D 1 1 0 1 D 0 0 1 0
E 0 0 0 0 E 2 1 1 0

Matrice des ressources attribuées Matrice des ressources demandées et non

obtenues
Algorithme
1. Trouver une rangé, R, de la matrice des ressources demandées et non obtenues, tel que
tous les éléments du vecteur R sont inférieur ou égale à A. Si aucune rangé ne vérifie ce
critère alors il y aura interblocage
2. 2- Supposer que le processus de la rangé choisie obtient toutes les ressources qu’il demande
et qu’il se termine. Indiqué que ce processus s’est achevé et ajouter ses ressources au
vecteur A
3. Répéter les étapes 1 et 2 jusqu’à ce que tous les processus soient marqués comme terminés
c.a.d. pas d’interblocage, ou jusqu’il y ait un interblocage.

- Après application de l’algorithme du banquier sur l’exemple donné : le processus D se terminer

puis les deux processus (A , E) puis les autres ( B , C). Donc, il n'y a pas d'interblocage.

Que fait cet algorithme? Il accorde les demandes aux processus qui pourront se terminer, récupère
leur ressources, et continue ainsi jusqu'à ce que tous les processus soient traités, ou bien jusqu'à ce
qu'il soit impossible de continuer dans ce cas il y a interblocage.

4.3.3 Détection de l'interblocage

Le système d'exploitation peut détecter l'interblocage en calculant le graphe d'allocation de
ressources. Une graphe d'allocation de ressource est un graphe orienté contenant deux types de
nœuds : les processus qui sont représentés par des cercles et les ressources représentées par des
carrés. Si nous avons plusieurs copies d'une ressource R, le carré aura plusieurs points l'intérieur
selon le nombre de copies :.

• : une ressource avec une seul copie

• une ressource avec deux copie.

Il y aura un arcs allant du processus P vers la ressource R si P demande R. Un arcs allant de la

ressource vers le processus si la ressource est allouer au processus:

Une copie de la ressource est allouer au processus P.

•
P
Le processus P demande une copie de la ressource.
•
P

3
Exemple : Soit les trois graphes d'allocation suivants
:
R1 R3 R1 R3 R1 P2

P3
P1 P2 P3 P1 P2 P3 P1

R2

R2 R2 P4

il n'y a pas de cycle, donc pas il y a un cycle, causant de il y a un cycle, mais il n'y a pas
d'interblocage l'iterblocage d'interblocage puisque R2 peut
se libérer.

À l'aide des exemples précédents, on s'aperçoit que:

• lorsque le graphe a un cycle et que les ressources n'ont qu'un élément dans le cycle, il y a
interblocage. Donc pour détecter ce type de problème, il suffit de bâtir le graphe, et de
détecter les cycles.
• lorsque les ressources dans le cycle ont plus d'un élément, on peut utilisé l'algorithme du
banquier pour détecter l'interblocage.

4.3.4 Prévention de l’interblocage :

Cette technique consiste éliminer la possibilité de survenue d’un interblocage en rendant fausse au
moins une des 4 conditions de sa survenue, c'est-à-dire nier une des 4 condition.

4.3.4.1 Nier l’exclusion mutuelle

Pas toujours faisable car il peut être difficile qu’une ressource critique puisse devenir non critique.
Par exemple au lieu d’imprimer directement, ce qui pourrait bloquer le processus si la ressource
n’est pas libre, le système d’exploitation remplace l’imprimante par un fichier, ce qui donne
l’illusion que l’attribution de la ressource a été possible, alors que ce n’est pas forcément le cas.
Une fois l’impression est terminé, ce fichier est mis en file d’attente d’impression. Un processus
unique accède a l’imprimante réelle en prenant les fichiers a imprimer un par un dans la file
d’attente. Ainsi, l’imprimante n’est plus partagée par plusieurs processus. Ce genre de système dit
de spooling (de l’abréviation SPOOL : Simultaneous Peripheral Operations OnLine).

4.3.4.2 Nier la détention et attente :

C.à.d. demander toutes les ressources à accès exclusif d’un coup, ce qui élimine l’imbrication des
sections critiques. On aura une seule section utilisant toutes les ressources. le principe de mise en
œuvre est de rendre atomique ou indivisible, la succession d’acquisition des ressources, on les
obtient toutes ou aucune, la phase d’acquisition des ressources devenant elle-même une section de
code critique (voire problème des philosophes). Nous utilisons un sémaphore d’exclusion mutuelle
comme suit :

Semaphore Mutex= 1 ;
P (Mutex)
/* Acquérir TOUTES les ressources utiles */

4
V (Mutex)
< SCritique utilisant “TOUTES” les ressources>
< Libération des ressources>

Processus P:  Processus Q:
P(Mutex) P(Mutex)
P(Mutex1) P(Mutex2)
P(Mutex2) P(Mutex1)
V(Mutex) V(Mutex)
/*utiliser  R1 et R2*/ /*utiliser  R1 et R2*/
V(Mutex2) V(Mutex1)
V(Mutex1) V(Mutex2)

Cette solution moins efficace car engendrant moins de concurrence :

4.3.4.3 Nier la réquisition :

Pas toujours faisable et peu souhaitable (risque de laisser une ressource dans un état incohérent)

4.3.4.4 Nier l’attente circulaire :

Pour cela, imposer un ordre dans l’acquisition des ressources, de telle sorte à ne pas avoir de cycle.
On suppose que les ressources sont ordonnées, par exemple, sont numérotées et acquérir les
ressources en respectant cet ordre, de manière croissante, ou décroissante.

4.4 Famine ou privation ( sarvation en anglais)

Un processus qui est en attente d'une ressource peut rester bloqué indéfiniment sans être pour autant
en situation d'interblocage. On dit que l'on a une situation de famine (en anglais starvation), La
différence essentielle réside dans le fait qu'il est possible de sortir de la situation de famine par suite
du changement du comportement des processus, alors qu'il n'est pas possible de sortir d'un
interblocage sans retirer autoritairement une ressource à un des processus en interblocage. Des
programmes corrects impliquent qu'il n'y ait pas de "possibilité" d'interblocage ou de famine.