Quand plusieurs utilisateurs écrivent en même temps, la base doit décider qui voit quoi, et qui attend qui.
⏱️ Durée : environ 90 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Chef de la concurrence
🎬 L'histoire
Deux membres de HashBox achètent la dernière place d'une formation au même instant. Les deux voient « 1 place disponible », les deux cliquent, les deux reçoivent une confirmation. Il y a maintenant 2 inscrits pour 1 place.
« Chaque transaction était correcte seule, dit Sam. Ensemble, elles ont produit un résultat impossible. C'est un problème d'isolation. »
Tu apprends les anomalies de concurrence, les niveaux d'isolation, les verrous et MVCC.
🎯 Ta mission
À la fin, je serai capable de :
- décrire les anomalies de concurrence (lecture sale, non répétable, fantôme, mise à jour perdue)
- énoncer les niveaux d'isolation et ce qu'ils empêchent
- expliquer le principe de MVCC
- utiliser verrouillage pessimiste et optimiste
- reconnaître et traiter un interblocage (deadlock)
🧩 Défi d'échauffement (5 XP)
Deux personnes réservent des places de concert sur le même site. Chacune voit « il reste 1 place ». Elles cliquent à quelques millisecondes d'écart. Que veux-tu qu'il arrive ? Imagine trois façons de résoudre ce conflit : (a) faire attendre la deuxième, (b) refuser la deuxième en lui disant de réessayer, (c) vendre quand même et gérer le surplus plus tard. Quels avantages et inconvénients ?
💡 Le concept
Les anomalies de concurrence
| Anomalie | Description | Exemple |
|---|---|---|
| Lecture sale (dirty read) | on lit une donnée modifiée par une transaction pas encore validée | on voit un solde qui sera annulé |
| Lecture non répétable | en relisant la même ligne, on obtient une autre valeur (modifiée et validée entre-temps) | deux lectures du solde donnent deux valeurs |
| Lecture fantôme | en relisant avec la même condition, de nouvelles lignes apparaissent | COUNT(*) change entre deux lectures |
| Mise à jour perdue (lost update) | deux transactions lisent la même valeur et l'écrasent chacune | deux ventes enregistrées comme une |
| Anomalie d'écriture (write skew) | deux transactions lisent un état, modifient des lignes différentes, et ensemble violent une règle | deux médecins de garde partent simultanément |
Les niveaux d'isolation (norme SQL)
| Niveau | Lecture sale | Non répétable | Fantôme |
|---|---|---|---|
| READ UNCOMMITTED | possible | possible | possible |
| READ COMMITTED | empêchée | possible | possible |
| REPEATABLE READ | empêchée | empêchée | possible (selon le SGBD) |
| SERIALIZABLE | empêchée | empêchée | empêchée |
Plus le niveau est fort, plus les garanties sont grandes, plus le coût (attentes, conflits à réessayer) est élevé. PostgreSQL utilise READ COMMITTED par défaut ; SQLite est SERIALIZABLE (un seul écrivain à la fois).
MVCC : plusieurs versions
MVCC (Multi-Version Concurrency Control) : au lieu de bloquer les lecteurs, la base garde plusieurs versions d'une ligne. Chaque transaction voit un instantané (snapshot) cohérent.
- les lecteurs ne bloquent pas les écrivains, et inversement ;
- les anciennes versions sont nettoyées plus tard (
VACUUMdans PostgreSQL).
Verrouillage
| Approche | Principe | Quand |
|---|---|---|
| Pessimiste | verrouiller dès la lecture : SELECT ... FOR UPDATE | conflits fréquents, opérations courtes |
| Optimiste | ne pas verrouiller ; à l'écriture vérifier que personne n'a modifié (colonne version) et réessayer sinon | conflits rares |
Verrouillage optimiste :
UPDATE places SET reservee = 1, version = version + 1
WHERE id = 7 AND version = 3; -- 0 ligne modifiée = quelqu'un d'autre est passé avant
Ne pas lire puis écrire : préfère l'opération atomique UPDATE stock SET n = n - 1 WHERE n > 0 à « lire n, puis écrire n−1 ».
L'interblocage (deadlock)
Deux transactions s'attendent mutuellement :
T1 : verrouille A, puis demande B
T2 : verrouille B, puis demande A
La base détecte le cycle et annule l'une des deux. Prévention : verrouiller toujours dans le même ordre, garder les transactions courtes, réessayer en cas d'échec.
Simuler une mise à jour perdue
import threading, time
stock = {"n": 1}
def acheter_naif(nom, resultats):
n = stock["n"] # lecture
time.sleep(0.01) # un autre acheteur passe ici
if n > 0:
stock["n"] = n - 1 # écriture basée sur une valeur périmée
resultats.append(nom)
res = []
fils = [threading.Thread(target=acheter_naif, args=(nom, res)) for nom in ("Ada", "Bob")]
for f in fils: f.start()
for f in fils: f.join()
print(res, stock) # ['Ada', 'Bob'] {'n': 0} : deux acheteurs pour une place
🔍 Exemple pas à pas
Problème : corriger la double réservation avec trois techniques.
import sqlite3
def nouvelle_base():
bd = sqlite3.connect(":memory:")
bd.executescript('''
CREATE TABLE places (id INTEGER PRIMARY KEY, client TEXT, version INTEGER NOT NULL DEFAULT 0);
INSERT INTO places (id) VALUES (1);
''')
bd.commit()
return bd
# 1. Opération atomique conditionnelle : un seul UPDATE qui vérifie ET modifie
def reserver_atomique(bd, client):
cur = bd.execute("UPDATE places SET client = ? WHERE id = 1 AND client IS NULL", (client,))
bd.commit()
return cur.rowcount == 1
bd = nouvelle_base()
print(reserver_atomique(bd, "Ada"), reserver_atomique(bd, "Bob")) # True False
# 2. Verrouillage optimiste : on lit la version, puis on écrit seulement si elle n'a pas changé
def reserver_optimiste(bd, client, version_lue):
cur = bd.execute("UPDATE places SET client = ?, version = version + 1 WHERE id = 1 AND client IS NULL AND version = ?",
(client, version_lue))
bd.commit()
return cur.rowcount == 1
bd = nouvelle_base()
v = bd.execute("SELECT version FROM places WHERE id = 1").fetchone()[0] # les deux lisent version 0
print(reserver_optimiste(bd, "Ada", v), reserver_optimiste(bd, "Bob", v)) # True False
# 3. Transaction exclusive (verrouillage pessimiste, version SQLite)
def reserver_pessimiste(bd, client):
bd.execute()
:
libre = bd.execute().fetchone()[]
libre:
bd.execute(, (client,))
bd.execute()
(libre)
Exception:
bd.execute()
bd = nouvelle_base()
(reserver_pessimiste(bd, ), reserver_pessimiste(bd, ))
Lecture :
- Atomique : la condition et la modification sont dans la même requête. Le plus simple, à préférer quand c'est possible.
- Optimiste : le deuxième
UPDATEne trouve plus la version attendue :rowcount = 0, le client doit réessayer. - Pessimiste : le verrou empêche tout autre écrivain pendant la lecture suivie de l'écriture.
Deux connexions qui se bloquent (SQLite) :
import os, sqlite3, tempfile
with tempfile.TemporaryDirectory() as d:
chemin = os.path.join(d, "t.db")
a = sqlite3.connect(chemin, timeout=0.2, isolation_level=None)
b = sqlite3.connect(chemin, timeout=0.2, isolation_level=None)
a.execute("CREATE TABLE t (x INTEGER)")
a.execute("BEGIN IMMEDIATE") # a prend le verrou d'écriture
try:
b.execute("BEGIN IMMEDIATE") # b doit attendre, puis abandonne
except sqlite3.OperationalError as e:
print("b bloqué :", e) # database is locked
a.execute("COMMIT")
✍️ À toi, avec aide (10 XP)
Pour chaque scénario, dis quelle anomalie se produit et quelle solution simple appliquer :
- Deux administrateurs ouvrent la fiche d'un membre, modifient chacun un champ différent, et enregistrent : le second écrase le premier.
- Un rapport lit deux fois
SELECT SUM(solde)pendant qu'un virement s'exécute et obtient des totaux différents. - Un compteur de visites est incrémenté par 20 processus avec « lire n, écrire n+1 ».
- Deux transactions verrouillent les comptes A puis B, et B puis A.
💡 Indice 1
Le 1 est une mise à jour perdue : colonne version ou ne mettre à jour que le champ modifié.
💡 Indice 2
Le 2 est une lecture non répétable : un seul SELECT ou un niveau d'isolation plus fort.
💡 Indice 3
Le 4 est un interblocage : ordre de verrouillage fixe.
✅ Réponse
- Mise à jour perdue → verrouillage optimiste (
version) ouUPDATEne portant que sur la colonne modifiée. - Lecture non répétable → faire un seul
SELECT, ou une transaction enREPEATABLE READ/snapshot. - Mise à jour perdue →
UPDATE compteur SET n = n + 1(atomique) au lieu de lire puis écrire. - Interblocage → toujours verrouiller dans le même ordre (par identifiant croissant), transactions courtes, réessai en cas d'annulation par la base.
🚀 À toi, en solo (20 XP)
Simulation de MVCC. Implémente une mini-base clé-valeur multi-versions :
- chaque écriture crée une nouvelle version avec un numéro de transaction ;
debut()renvoie un instantané (numéro de version actuel) ;lire(snapshot, cle)renvoie la dernière version visible par ce snapshot ;ecrire(snapshot, cle, valeur)échoue (conflit) si la clé a été modifiée depuis le snapshot (premier validateur gagne).
Teste : une transaction longue lit toujours la même valeur malgré des écritures concurrentes, et deux écritures concurrentes sur la même clé produisent un conflit pour la seconde.
✅ Pistes de correction
class MVCC:
def __init__(self):
self.versions = {} # cle -> liste de (numero, valeur)
self.horloge = 0
def debut(self):
return self.horloge
def lire(self, snapshot, cle):
visibles = [(n, v) for n, v in self.versions.get(cle, []) if n <= snapshot]
return visibles[-1][1] if visibles else None
def ecrire(self, snapshot, cle, valeur):
dernieres = self.versions.get(cle, [])
if dernieres and dernieres[-1][0] > snapshot:
raise RuntimeError("conflit d'écriture : la clé a changé depuis le snapshot")
self.horloge += 1
self.versions.setdefault(cle, []).append((self.horloge, valeur))
bd = MVCC()
s0 = bd.debut(); bd.ecrire(s0, , )
long = bd.debut()
(bd.lire(long, ))
t1 = bd.debut(); t2 = bd.debut()
bd.ecrire(t1, , )
(bd.lire(long, ))
:
bd.ecrire(t2, , )
RuntimeError e:
(e)
(bd.lire(bd.debut(), ))
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Lire puis écrire (read-modify-write) | Mises à jour perdues | Opération atomique en une requête |
| Verrous pris dans un ordre différent | Interblocage | Ordre fixe (par exemple par identifiant) |
| Pas de réessai en cas de conflit | Erreurs rares mais réelles en production | Boucle de réessai avec limite |
| Isolation maximale partout | Beaucoup d'abandons, performances en baisse | Choisir le niveau selon le besoin |
🐉 Mini-boss (40 XP)
Banque concurrente. Simule 8 threads qui font 500 virements aléatoires chacun entre 10 comptes (SQLite en fichier temporaire, une connexion par thread, timeout suffisant).
- Version naïve : lire les soldes puis écrire. Montre que la somme totale change (argent créé ou détruit).
- Version correcte :
UPDATE ... SET solde = solde - ? WHERE id = ? AND solde >= ?dans une transactionBEGIN IMMEDIATE, avec réessai en cas dedatabase is locked. - Vérifie l'invariant : la somme totale reste constante et aucun solde n'est négatif.
- Ajoute un détecteur de deadlock simulé avec deux verrous Python pris dans des ordres opposés, et montre la correction (ordre global).
- Mesure le débit (virements/seconde) des deux versions.
✅ Pistes de correction
Un bon travail : la version naïve utilise SELECT solde ... puis UPDATE ... SET solde = ? avec la valeur lue ; on observe que la somme finale s'écarte de 10 × solde initial. La version correcte utilise isolation_level=None, BEGIN IMMEDIATE, deux UPDATE atomiques avec condition solde >= montant (et on annule si le premier ne modifie aucune ligne), et réessaie sur OperationalError. L'invariant est vérifié par SELECT SUM(solde) et SELECT COUNT(*) WHERE solde < 0. Le deadlock est reproduit avec threading.Lock (acquire(timeout=...) pour le détecter) puis corrigé par sorted((a, b)) avant d'acquérir. Le débit de la version correcte est plus faible (écrivains sérialisés) mais le résultat est juste.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Une lecture non répétable est :
- A. une lecture trop lente
- B. une donnée qui change entre deux lectures dans la même transaction
- C. une lecture interdite
2. MVCC permet :
- A. de supprimer les index
- B. de chiffrer la base
- C. aux lecteurs de ne pas bloquer les écrivains
3. Pour éviter une mise à jour perdue sur un compteur, on utilise :
- A. UPDATE compteur SET n = n + 1
- B. lire n puis écrire n+1
- C. un fichier texte
4. 🔁 Révision mission 08 : L'atomicité signifie :
- A. des transactions rapides
- B. tout ou rien
- C. des données chiffrées
5. 🔁 Révision mission 08 : Un ROLLBACK :
- A. valide la transaction
- B. supprime la table
- C. annule les modifications de la transaction en cours
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Dans quelles situations de ta vie « lis-tu puis écris-tu » sans savoir si l'information a changé entre-temps ?
- Entre attendre (pessimiste) et réessayer (optimiste), laquelle préfères-tu et pourquoi ?
🎒 À retenir
- Anomalies : lecture sale, non répétable, fantôme, mise à jour perdue.
- Niveaux d'isolation : du plus faible au plus fort.
- MVCC : plusieurs versions, les lecteurs ne bloquent pas.
- Optimiste (version) ou pessimiste (verrou).
- Ordre de verrouillage fixe contre les interblocages.
flowchart LR
T(["Isolation, verrouillage et concurrence"])
T --> R1["1. Anomalies : lecture sale, non répétable, fantôme, mise à jour perdue."]
T --> R2["2. Niveaux d'isolation : du plus faible au plus fort."]
T --> R3["3. MVCC : plusieurs versions, les lecteurs ne bloquent pas."]
T --> R4["4. Optimiste version ou pessimiste verrou."]
T --> R5["5. Ordre de verrouillage fixe contre les interblocages."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Chef de la concurrence
← Mission 08 — Transactions et ACID · Mission 10 — PostgreSQL en pratique →
HEF-070 — Bases de données

