Qu'est-ce qui cause les interblocages et comment les prévenir?

Question

Accepted Answer

Un **interblocage** (deadlock) se produit quand deux (ou plusieurs) transactions détiennent chacune un verrou dont l'autre a besoin, de sorte qu'aucune ne peut avancer — elles restent bloquées en attente l'une de l'autre indéfiniment. Les bases de données détectent les interblocages et les résolvent en **avortant une transaction** (la « victime »), qui doit être réessayée. Comprendre les causes et la prévention est important pour les applications concurrentes.

## Comment un interblocage se produit

```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
```

## Comment les bases de données gèrent les interblocages

```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.
```

## Stratégies de prévention

```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)
```

La **prévention n°1** est l'**ordre d'acquisition cohérent des verrous** : si toutes les transactions acquièrent les verrous dans le même ordre (par exemple, toujours l'identifiant le plus bas en premier), l'attente circulaire ne peut pas se former.

## Le modèle de réessai

```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.
```

## Pourquoi c'est important

Les interblocages sont un problème de concurrence important dans les bases de données — ils se produisent dans toute application avec des transactions concurrentes qui modifient des données qui se chevauchent, et les comprendre est une connaissance précieuse de niveau senior pour construire des systèmes concurrents robustes.

Comprendre la **cause** — deux transactions détenant chacune un verrou dont l'autre a besoin, créant une attente circulaire où aucune ne peut avancer — est la base.

Savoir comment les bases de données **gèrent** les interblocages (détecter le cycle et avorter une transaction comme victime, qui doit être réessayée) est important car cela signifie que votre **application doit gérer les erreurs d'interblocage avec une logique de réessai** — les interblocages ne peuvent pas être complètement éliminés, donc le code concurrent résilient capture l'erreur d'interblocage et réessaie (un modèle standard, important).

Les **stratégies de prévention** sont la connaissance pratique clé, en particulier la technique n°1 : l'**ordre d'acquisition cohérent des verrous** (acquérir toujours les verrous dans le même ordre dans toutes les transactions, ce qui rompt la condition d'attente circulaire qui cause les interblocages) — ainsi que garder les transactions courtes (tenir les verrous brièvement), accéder aux ressources dans un ordre cohérent, et éviter les opérations longues dans les transactions.

Comme les interblocages causent des problèmes réels (transactions échouées, erreurs, dégradation des performances) dans les applications de bases de données concurrentes, et puisque comprendre leur cause (attentes circulaires de verrous), leur prévention (en particulier l'ordre cohérent des verrous et les transactions courtes), et la nécessité de la logique de réessai est ce qui vous permet de construire des systèmes concurrents robustes, comprendre les interblocages est une connaissance précieuse de niveau senior pour toute application avec un accès significatif à la base de données concurrente — une préoccupation opérationnelle fréquemment pertinente et un sujet d'entretien avancé courant démontrant une compréhension de la concurrence des bases de données et de la résilience.