Qu'est-ce qu'une impasse?

Question

Lors de l'écriture d'applications multithreads, l'un des problèmes les plus courants est l'interblocage.

Ma question à la communauté est la suivante:

Qu'est-ce qu'une impasse? Comment les détectez-vous? Les manipulez-vous? Et enfin, comment les empêchez-vous de se produire?

Answer 1

Une serrure se produit lorsque plusieurs processus essayez d'accéder à la même ressource en même temps.

Un processus perd et doit attendre que l'autre à la fin.

Un blocage se produit lorsque le processus d'attente est toujours tenue sur une autre ressource que la première besoins avant de pouvoir terminer.

Donc, un exemple:

La ressource A et B de ressource sont utilisés par les processus X et processus Y

• X commence à utiliser A.
• X et Y essayer de démarrer à l'aide de B
• Y "gagne" et obtient B
• maintenant Y a besoin d'utiliser Un
• Un est verrouillé par X, qui est en attente pour Y

La meilleure façon d'éviter les blocages est pour éviter d'avoir des processus de croix au-dessus de cette manière. Réduire le besoin de verrouiller n'importe quoi comme beaucoup que vous le pouvez.

Dans les bases de données d'éviter de faire beaucoup de changements pour les différentes tables dans une seule opération, d'éviter les déclencheurs et de passer à optimistes/sale/nolock lit autant que possible.

Answer 2

Les blocages ne se produiront que si vous avez deux ou plusieurs verrous qui peuvent être acquis en même temps et qu'ils sont saisis dans un ordre différent.

Les moyens d'éviter les blocages sont les suivants:

• éviter d'avoir des verrous (si possible),
• éviter d'avoir plus d'une serrure
• toujours prendre les serrures dans le même ordre.

Answer 3

Un blocage se produit lorsqu'un thread attend quelque chose qui ne se produit jamais.

Cela se produit généralement lorsqu'un thread attend un mutex ou un sémaphore qui n'a jamais été publié par le propriétaire précédent.

Cela arrive aussi fréquemment lorsque vous avez une situation impliquant deux threads et deux verrous comme celui-ci:

 Thread 1               Thread 2

Lock1->Lock();         Lock2->Lock();
WaitForLock2();        WaitForLock1();   <-- Oops!
 

Vous les détectez généralement parce que les événements attendus ne se produisent jamais ou que l'application est totalement bloquée.

Answer 4

Encore une fois, Jeff a la réponse. ;-)

Answer 5

Vous pouvez consulter ces merveilleux articles , dans la section Impasse . C'est en C # mais l'idée est toujours la même pour les autres plateformes. Je cite ici pour une lecture facile

Un blocage se produit lorsque deux threads attendent chacun une ressource détenue par l'autre. Aucun des deux ne peut continuer. Le moyen le plus simple d'illustrer cela est d'utiliser deux verrous:

 object locker1 = new object();
object locker2 = new object();

new Thread (() => {
                    lock (locker1)
                    {
                      Thread.Sleep (1000);
                      lock (locker2);      // Deadlock
                    }
                  }).Start();
lock (locker2)
{
  Thread.Sleep (1000);
  lock (locker1);                          // Deadlock
}