Was ist eine Deadlock?

Ein Deadlock ist eine ausweglose Situation in der Multithread-Programmierung, bei der zwei oder mehr Threads sich gegenseitig blockieren, während sie auf Ressourcen warten, die von anderen Threads derselben Gruppe genutzt werden.

Bedingungen für das Auftreten eines Deadlocks (Coffman-Bedingungen):

1. Gegenseitiger Ausschluss (Mutual Exclusion): Ressourcen können nicht gleichzeitig von mehreren Threads genutzt werden.
2. Hold and Wait (Halten und Warten): Threads, die bereits eine Ressource besitzen, warten auf eine weitere Ressource, die von einem anderen Thread gehalten wird.
3. Keine Preemption (Keine Prellung): Eine Ressource kann einem Thread, der sie besitzt, nicht gewaltsam weggenommen werden; sie kann nur vom Thread selbst freigegeben werden.
4. Circular Wait (Kreisförmiges Warten): Es gibt eine Kette von zwei oder mehr Threads, bei denen jeder auf eine Ressource wartet, die vom nächsten in der Kette gehalten wird (kreisförmiges Warten).

Ein einfaches Beispiel für einen Deadlock:

Zwei Threads, zwei Ressourcen (A und B).

• Thread 1 erwirbt Ressource A.
• Thread 2 erwirbt Ressource B.
• Thread 1 versucht, Ressource B zu erlangen (die von Thread 2 gehalten wird).
• Thread 2 versucht, Ressource A zu erlangen (die von Thread 1 gehalten wird).

Beide Threads sind für immer blockiert.

// Einfaches Beispiel zur Simulation eines Deadlocks mit lock
object resourceA = new object();
object resourceB = new object();

void Thread1Method()
{
    lock (resourceA) // Thread 1 erwirbt A
    {
        Console.WriteLine("Thread 1 hat Ressource A erlangt");
        Thread.Sleep(100); // Kurze Pause, um die Möglichkeit eines Thread-Wechsels zu demonstrieren
        lock (resourceB) // Thread 1 versucht, B zu erlangen
        {
            Console.WriteLine("Thread 1 hat Ressource B erlangt");
        }
    }
}

void Thread2Method()
{
    lock (resourceB) // Thread 2 erwirbt B
    {
        Console.WriteLine("Thread 2 hat Ressource B erlangt");
        Thread.Sleep(100); // Kurze Pause
        lock (resourceA) // Thread 2 versucht, A zu erlangen
        {
            Console.WriteLine("Thread 2 hat Ressource A erlangt");
        }
    }
}

// Das Erstellen und Starten der Threads kann zu einem Deadlock führen.
// new Thread(Thread1Method).Start();
// new Thread(Thread2Method).Start();

// Das Ausführen dieses Codes kann, aber muss nicht, einen Deadlock demonstrieren,
// da die Ausführungsreihenfolge vom Scheduler abhängt.
// Wenn Thread 1 A erlangt und Thread 2 B, bevor der erste
// B erlangen kann, entsteht ein Deadlock.

Deadlocks lassen sich oft verhindern durch:

• Ressourcen in einer festen Reihenfolge anfordern (immer in derselben Reihenfolge).
• Verwendung von Methoden mit Timeout beim Ressourcenanfordern (versuchen, eine Ressource für eine bestimmte Zeit zu erlangen).
• Design ohne die Notwendigkeit, mehrere Sperren gleichzeitig zu halten.
• Verwendung von atomaren Operationen oder höherstufigen Synchronisationsprimitive (z.B. Monitor.TryEnter, ReaderWriterLockSlim).

Deadlocks sind schwer zu debuggen, da sie vom Ablauf der Thread-Ausführung abhängen und oft nur unter Last auftreten. Visual Studio bietet Werkzeuge zur Erkennung und Analyse dieser Situationen.