Deadlock échantillon .net?

Question

Quelqu'un peut-il donner un simple code exemple Deadlock en C #? Et s'il vous plaît dire la façon la plus simple de trouver l'impasse dans votre échantillon de code C #. (Peut-être l'outil qui permet de détecter le verrou mort dans l'exemple de code donné.)

NOTE: Je VS 2008

Answer 1

d'une manière commune est que si vous avez des verrous imbriqués qui ne sont pas acquises dans le même ordre. Discussion 1 pourrait acquérir un verrou A et 2 du fil pourrait acquérir un verrou B et ils interblocage.

var a = new object();
var b = new object();

lock(a) {
   lock(b) {

   }
}

// other thread
lock (b) { 
  lock(a) {

  }
}

edit: exemple non-lock .. en utilisant waithandles. On suppose Socrate et Descartes ont des steaks et ils ont tous deux, étant philosophes bien maniéré, nécessitent à la fois une fourchette et un couteau pour manger. Cependant, ils ont seulement un ensemble d'argenterie, de sorte qu'il est possible pour chacun d'attraper un ustensile, puis attendre indéfiniment l'autre main sur leur ustensile.

Voir Dining problème Philosophale

WaitHandle fork = new AutoResetEvent(), knife = new AutoResetEvent();

while(Socrates.IsHungry) {
   fork.WaitOne();
   knife.WaitOne();
   Eat();
   fork.Set();
   knife.Set();
} 

// other thread
while(Descartes.IsHungry) {
   knife.WaitOne();
   fork.WaitOne();
   Eat();
   knife.Set();
   fork.Set();
} 

Answer 2

Ceci est un code typique pour créer une impasse dans le code C #. Checkout cet article MSDN: http://msdn.microsoft.com/en-us/ magazine / cc188793.aspx

using System;

using System.Threading;


public class Simple {

    static object A = new object();

    static object B = new object();


    static void MethodA()
    {
        Console.WriteLine("Inside methodA");
        lock (A)
        {
            Console.WriteLine("MethodA: Inside LockA and Trying to enter LockB");
            Thread.Sleep(5000);           
            lock (B)
            {
                Console.WriteLine("MethodA: inside LockA and inside LockB");
                Thread.Sleep(5000);
            }
            Console.WriteLine("MethodA: inside LockA and outside LockB");
        }
        Console.WriteLine("MethodA: outside LockA and outside LockB");
    }

    static void MethodB()
    {
        Console.WriteLine("Inside methodB");
        lock (B)
        {
            Console.WriteLine("methodB: Inside LockB");
            Thread.Sleep(5000);
            lock (A)
            {
                Console.WriteLine("methodB: inside LockB and inside LockA");
                Thread.Sleep(5000);
            }
            Console.WriteLine("methodB: inside LockB and outside LockA");
        }
        Console.WriteLine("methodB: outside LockB and outside LockA");
    }

    public static void Main(String[] args)
    {

        Thread Thread1 = new Thread(MethodA);
        Thread Thread2 = new Thread(MethodB);
        Thread1.Start();
        Thread2.Start();
        Console.WriteLine("enter.....");
        Console.ReadLine();

    }
}

Answer 3

Pour l'exemple de code de blocage, essayez d'utiliser lock(this) dans votre classe pour simuler le scénario de blocage. Commander cet exemple .

Après deux articles de lecture dignes détecte l'impasse lors de l'exécution et discute des façons de les éviter.

1. Deadlock surveiller par Stephen Toub.
2. TimedLock Encore une fois par Ian Griffiths.

Answer 4

Il y a une autre façon de parvenir à une impasse en C #. Etant donné que le numéro de .NET 2.0 SP1 de fils dans la piscine sont limitées à 250 (de 25 dans la version précédente) par noyau.

Alors, techically, vous pouvez commencer à trop de tâches dans la piscine qui attendent l'achèvement d'une autre opération asynchrone (qui est exécuté par pool de threads). Par conséquent, la tâche dans la piscine ne sera pas libéré et tâche async ne démarre pas parce qu'il n'y a pas de threads disponibles.

Vous trouverez par exemple et une explication plus précise ici: Programmation du pool de threads. blocages

Answer 5

Pour répondre à la partie de votre question sur la détection de l'impasse, je doute plutôt que cela est en général possible. Il est similaire en question avec le problème de l'arrêt, vous ne pouvez pas calculer efficacement la sémantique. Une façon de surmonter ce problème est d'utiliser un chien de garde qui périodiquement scrutin, chaque fil si elle est encore en vie et lui donner un certain délai pour répondre, si 2 threads ne répondent pas, vous pouvez supposer qu'ils sont soit occupés ou ils sont dead- verrouillé.