Deadlock Probe in .net?

Question

Kann jemand einen einfachen Deadlock Beispielcode in C # geben? Und bitte die einfachste Art und Weise erzählen in Ihrem C # Codebeispiel zu finden Deadlock. (Kann das Werkzeug sein, die das Riegelschloss in dem gegebenen Beispielcode erkennen.)

Hinweis: Ich habe VS 2008

Answer 1

ein gemeinsamer Weg ist, wenn Sie verschachtelte Sperren haben, die nicht in der gleichen Reihenfolge erworben. Thema 1 könnte Sperre A erwerben und Faden 2 könnte Sperre B erwerben und sie würden eine Sackgasse.

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

lock(a) {
   lock(b) {

   }
}

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

  }
}

edit: Nicht-Sperre Beispiel .. mit waithandles. Angenommen, Sokrates und Descartes haben Steaks und sie beide, sind gut erzogene Philosophen, erfordern sowohl eine Gabel und ein Messer, um zu essen. Allerdings haben sie nur ein Satz von Besteck, so dass es möglich ist, für jedes Utensil zu packen und dann für immer warten, bis die andere Hand über ihr Utensil.

Sehen Sie die Restaurants Philosophenweg Problem

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

Dies ist ein typischer Code ein Deadlock in C # -Code zu erstellen. Kasse in diesem MSDN-Artikel: http://msdn.microsoft.com/en-us/ Magazin / 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

Für den Deadlock Beispielcode, versuchen Sie in Ihrer Klasse mit lock(this) das Deadlock-Szenario zu simulieren. Kasse dieses Beispiel .

Nach zwei würdigen Lese Artikel erkennt den Stillstand zur Laufzeit und beschreibt Möglichkeiten, sie zu vermeiden.

1. Deadlock überwachen von Stephen Toub.
2. TimedLock Wieder von Ian Griffiths.

Answer 4

Es gibt eine weitere Möglichkeit, Deadlock in C # zu erreichen. Da .NET 2.0 SP1 Anzahl von Threads, die im Pool wird auf 250 (von 25 in früheren Version) pro Kern beschränkt.

Also, techically, können Sie zu viele Aufgaben im Pool, dass Wartezeit für den Abschluss für einen anderen async Betrieb starten (das durch Threadpool ausgeführt wird). Daher wird im Pool Aufgabe nicht freigegeben und async Aufgabe beginnen wird nicht, weil es keine verfügbaren Threads sind.

Hier finden Sie Beispiel und genauere Erklärung hier: den Thread-Pool Programmierung. Deadlocks

Answer 5

Um den Teil Ihrer Frage zu Deadlock-Erkennung zu beantworten, ich eher Zweifel, dass dies in der Regel möglich. Ähnlich verhält es sich in Frage mit dem Halteproblem, nicht effektiv die Semantik berechnen kann. Eine Möglichkeit, dies zu überwinden, ist ein Watchdog zu verwenden, die in regelmäßigen Abständen jeden Thread abfragen würde, wenn er noch am Leben ist und geben ihm eine gewisse Timeout Antwort, wenn zwei Threads nicht reagieren tun, können Sie davon ausgehen, sie sind entweder zu beschäftigt oder sie sind Fristen verriegelt.