Was verursacht Deadlocks und wie verhindert man sie?

Question

Accepted Answer

Ein **Deadlock** tritt auf, wenn zwei (oder mehr) Transaktionen jeweils ein Schloss halten, das die andere benötigt, sodass keine voranschreiten kann — sie sind für immer fest, während sie auf die jeweils andere warten. Datenbanken erkennen Deadlocks und beheben sie durch **Abbruch einer Transaktion** (das "Opfer"), die erneut versucht werden muss. Das Verständnis der Ursachen und Prävention ist wichtig für gleichzeitige Anwendungen.

## Wie ein Deadlock entsteht

```text
Transaction A: locks row 1, then wants row 2
Transaction B: locks row 2, then wants row 1
→ A waits for B (to release row 2), B waits for A (to release row 1) → DEADLOCK
  Neither can proceed; they're waiting on each other in a cycle.
```

```sql
-- Transaction A                    -- Transaction B (concurrent)
BEGIN;                              BEGIN;
UPDATE accounts SET .. WHERE id=1;  UPDATE accounts SET .. WHERE id=2;  -- each locks a row
UPDATE accounts SET .. WHERE id=2;  UPDATE accounts SET .. WHERE id=1;  -- each wants the OTHER's
-- → DEADLOCK: the database aborts one transaction
```

## Wie Datenbanken Deadlocks handhaben

```text
Databases DETECT deadlocks (find the cycle of waiting transactions) and resolve them
by ABORTING one transaction (the victim) with a deadlock error → it must RETRY.
→ Your application must handle the deadlock error and retry the transaction.
```

## Präventionsstrategien

```text
✓ CONSISTENT LOCK ORDERING — always acquire locks in the SAME order (e.g. always
  lock the lower account id first). This breaks the cycle → the #1 prevention technique.
✓ Keep transactions SHORT — hold locks for less time (less chance to overlap)
✓ Access tables/rows in a consistent order across all transactions
✓ Use lower isolation levels where appropriate (less locking)
✓ Avoid user interaction / long operations inside a transaction (holds locks too long)
✓ Handle deadlock errors with RETRY logic (deadlocks can't be fully eliminated)
```

Die **#1 Prävention** ist **konsistente Sperrreihenfolge**: Wenn alle Transaktionen Sperren in der gleichen Reihenfolge erwerben (z. B. immer zuerst die niedrigere ID), kann sich die zirkuläre Abhängigkeit nicht bilden.

## Das Wiederholungsmuster

```text
Since deadlocks can still happen, applications should catch the deadlock error and
RETRY the transaction (often a few times with a small delay). This is standard
resilience for concurrent database code.
```

## Warum es wichtig ist

Deadlocks sind ein wichtiges Concurrency-Problem in Datenbanken — sie treten in jeder Anwendung mit gleichzeitigen Transaktionen auf, die überlappende Daten ändern, und das Verständnis dafür ist wertvoll für Senior-Level-Wissen beim Aufbau robuster gleichzeitiger Systeme.

Das Verständnis der **Ursache** — zwei Transaktionen, von denen jede ein Schloss hält, das die andere benötigt, wodurch eine zirkuläre Abhängigkeit entsteht, in der keine voranschreiten kann — ist die Grundlage.

Zu wissen, wie Datenbanken **Deadlocks handhaben** (den Zyklus erkennen und eine Transaktion als Opfer abbrechen, die erneut versucht werden muss), ist wichtig, da es bedeutet, dass Ihre **Anwendung Deadlock-Fehler mit Wiederholungslogik handhaben muss** — Deadlocks können nicht vollständig eliminiert werden, daher fängt zuverlässiger gleichzeitiger Code den Deadlock-Fehler ab und versucht erneut (ein Standard- und wichtiges Muster).

Die **Präventionsstrategien** sind das wichtige praktische Wissen, besonders die #1-Technik: **konsistente Sperrreihenfolge** (immer Sperren in der gleichen Reihenfolge über alle Transaktionen hinweg erwerben, was die zirkuläre Abhängigkeitsbedingung bricht, die Deadlocks verursacht) — zusammen mit kurzen Transaktionen (Sperren kurz halten), Zugriff auf Ressourcen in konsistenter Reihenfolge und Vermeidung langer Operationen innerhalb von Transaktionen.

Da Deadlocks echte Probleme verursachen (fehlgeschlagene Transaktionen, Fehler, beeinträchtigte Leistung) in gleichzeitigen Datenbankanwendungen, und da das Verständnis ihrer Ursache (zirkuläre Sperr-Abhängigkeiten), Prävention (besonders konsistente Sperrreihenfolge und kurze Transaktionen) und die Notwendigkeit von Wiederholungslogik es Ihnen ermöglicht, robuste gleichzeitige Systeme zu bauen, ist das Verständnis von Deadlocks wertvoles Senior-Level-Wissen für jede Anwendung mit signifikantem gleichzeitigem Datenbankzugriff — ein häufig relevantes operatives Anliegen und ein häufig behandeltes fortgeschrittenes Interview-Thema, das Verständnis für Datenbank-Concurrency und Resilienz demonstriert.