deadlock

Deadlock (Verklemmung)

Kurz: Ein Deadlock ist ein Stillstand, bei dem zwei oder mehr Threads oder Prozesse gegenseitig auf Ressourcen warten, die der jeweils andere festhält – keiner kann weitermachen.

Genauer: Klassisch: Thread A hält Sperre 1 und wartet auf Sperre 2, Thread B hält Sperre 2 und wartet auf Sperre 1. Das Programm hängt, ohne abzustürzen. Deadlocks treten bei Sperren (Mutex), Datenbank-Transaktionen und Netzwerk-Protokollen auf.

Im Detail

import threading, time
 
sperre_a = threading.Lock()
sperre_b = threading.Lock()
 
def eins():
    with sperre_a:
        time.sleep(0.1)
        with sperre_b:        # wartet auf B
            pass
 
def zwei():
    with sperre_b:
        time.sleep(0.1)
        with sperre_a:        # wartet auf A -> Deadlock
            pass

Vier Bedingungen (Coffman)

Ein Deadlock braucht alle vier gleichzeitig:

1. Gegenseitiger Ausschluss: Die Ressource kann nur einer nutzen.
2. Halten und Warten: Ein Thread hält eine Ressource und fordert weitere an.
3. Keine Verdrängung: Ressourcen werden nicht gewaltsam entzogen.
4. Zyklisches Warten: A wartet auf B, B auf A.

Vermeiden

• Feste Reihenfolge: Alle Threads fordern Sperren in derselben Reihenfolge an (immer erst A, dann B).
• Zeitlimits: acquire(timeout=...), danach aufgeben und neu versuchen.
• Weniger Sperren: kleine kritische Abschnitte, keine Sperre während Netzwerk- oder Dateizugriffen halten.
• Alternativen ohne gemeinsamen Zustand: Nachrichten, unveränderliche Daten.

Verwandt: Livelock (die Threads reagieren ständig aufeinander, kommen aber nicht voran) und Starvation (ein Thread kommt nie an die Reihe). Siehe auch Race Condition und Thread.

Siehe auch: Mutex, Race Condition, Thread, Nebenläufigkeit