Reconnaitre une situation de deadlock

Bonjour mon exercice est de reconnaitre une situation de deadlock, c'est à dire 2 threads qui attendent indéfiniment la terminaison de l'autre thread.

Voici le code ou je dois reconnaitre la situation de deadlock et savoir comment l'éviter, si vous pouvez m'aider, je suis pas très à l'aise avec ça !

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

semaphore *mutex, *data; void me() { P(mutex); /* do something */ P(data); /* do something else */   V(mutex); /* clean up */ V(data); }   void you() { P(data) P(mutex);   /* do something */   V(data); V(mutex); }

---

Merci d'avance !

Bonjour,

Il faut prendre des cas avec ton exemple, et les derouler pour voir si tu trouves une situation de deadlock.

Un moyen mnemotechnique pour P et V :

• Puis-je [prendre ce mutex]
• Vas-y [je le relache, faites ce que vous voulez avec]

Exemple au hasard, dans lequel je suppose que chaque mutex n'est prenable qu'une seule fois :
le thread1 lance me().
T1 : Puis-je (mutex) -> Oui, je suis le premier. Je prends donc ce lock.
Je fais d'autres choses ; pendant ce temps, le second thread arrive, et appelle you() :
T2 : Puis-je (data) -> Oui, je suis le premier. Je prends donc ce lock.
Maintenant, T2 est mis a la queue, et T1 reprend la main :
T1 : Puis-je (data) -> Non, il est deja pris. Attente de liberation.
T2 finit par etre ordonnancé :
T2 : Puis-je (mutex) -> Non, il est deja pris. Attente de liberation.

Tu as donc un magnifique cas d'interblocage dans ce cas precis. Je ne pense pas qu'il y en ait d'autres, mais que ca ne t'empeche pas de derouler l'algo a la main.

Si tu souhaitais faire un programme correcte, il te suffit de modifier l'ordre des appels dans une fonction. Tu verras d'ailleurs que, si tu as bien mis tout le code, ca ne change pas le comportement de la fonction.

Pose des questions si tu ne comprends pas.

Merci !

Est-ce qu'un thread peut avoir plusieurs locks à la fois ?

Bonjour,

Citation:

---

Envoyé par guipe

Est-ce qu'un thread peut avoir plusieurs locks à la fois ?

---

Ca dépend de tes semaphores :
dans le cas d'un semaphore qui ne peut etre pris qu'une fois :
si tu penses a ceci :

Code:

---

1 2 3 4 5 6 7 8 9

void you() { P(data) P(mutex);   /* do something */   V(data); V(mutex); }

---

La réponse est oui.

Si tu penses a ceci :

Code:

---

1 2 3 4 5 6 7 8 9

void you() { P(data) P(data);   /* do something */   V(data); V(data); }

---

La réponse est non.

Dans le cas d'un mutex qui peut etre pris plusieurs fois, la reponse est oui, tant que le mutex est prenable.

Merci !