Guide de Contrôle de Concurrency dans les SGBD - Pour Débutants

Salut à toi, futur(e) magicien(ne) de bases de données ! Aujourd'hui, nous allons entreprendre un voyage passionnant à travers le monde du Contrôle de Concurrency dans les Systèmes de Gestion de Bases de Données (SGBD). Ne t'inquiète pas si tu es nouveau(e) dans ce domaine ; je serai ton guide attentionné, et nous explorerons ce sujet pas à pas. Alors, prends une tasse de café et plongeons dedans !

DBMS - Concurrency Control

Qu'est-ce que le Contrôle de Concurrency ?

Avant de rentrer dans les détails, comprenons ce qu'est le contrôle de concurrency. Imagine un restaurant bondé où plusieurs serveurs essaient de prendre des commandes et de servir des plats simultanément. Sans une coordination adéquate, le chaos règnerait ! De même, dans une base de données, plusieurs utilisateurs ou processus pourraient tenter d'accéder et de modifier les données en même temps. Le contrôle de concurrency est comme le chef de service qui s'assure que tout se déroule sans conflits.

Maintenant, explorons les principales techniques utilisées pour le contrôle de concurrency dans les SGBD.

Protocoles Basés sur les Verrous

Comprendre les Verrous

Les verrous sont comme des pancartes "Ne pas perturber" sur les portes des chambres d'hôtel. Lorsqu'une transaction a besoin d'accéder à des données, elle met un verrou dessus, disant aux autres : "Hey, je suis en train de bosser ici !"

Types de Verrous

Type de Verrou	Description	Cas d'Utilisation
Verrou Partagé (S)	Permet à plusieurs transactions de lire les données	Lire des données sans modifications
Verrou Exclusif (X)	Seule une transaction peut détenir ce verrou	Écrire ou mettre à jour des données

Protocole de Verrouillage en Deux Phases (2PL)

Ce protocole est comme une danse avec deux mouvements principaux :

Phase de Croissance : Acquérir des verrous, ne pas en relâcher.
Phase de Réduction : Relâcher des verrous, ne pas en acquérir.

Voyons un exemple simple :

BEGIN TRANSACTION;
-- Phase de Croissance
LOCK TABLE users IN EXCLUSIVE MODE;
UPDATE users SET balance = balance - 100 WHERE id = 1;
LOCK TABLE transactions IN EXCLUSIVE MODE;
INSERT INTO transactions (user_id, amount) VALUES (1, -100);
-- Phase de Réduction
UNLOCK TABLE users;
UNLOCK TABLE transactions;
COMMIT;

Dans cet exemple, nous verrouillons d'abord les tables dont nous avons besoin, effectuons nos opérations, puis relâchons les verrous avant de valider la transaction.

Les Deadlocks : La Danse Mal Tournée

Imagine deux danseurs qui attendent tous deux que l'autre fasse un mouvement. C'est un deadlock ! Dans les bases de données, cela se produit lorsque deux transactions attendent l'une l'autre pour relâcher un verrou.

Pour éviter les deadlocks, nous utilisons des techniques comme :

Timeout : Si une transaction attend trop longtemps, elle est annulée.
Détection de Deadlocks : Le système cherche activement les deadlocks et les résout.

Protocoles Basés sur les Horodatages

Passons maintenant aux protocoles basés sur les horodatages. Ce sont comme donner à chaque transaction un ticket unique avec un horodatage lorsqu'elle entre dans le système.

Protocole de Base d'Ordre par Horodatage (TO)

Dans ce protocole, nous utilisons les horodatages pour déterminer l'ordre des opérations conflictuelles. C'est comme servir les clients en fonction de leur heure d'arrivée au restaurant.

Voici comment cela fonctionne :

Chaque élément de données X a deux valeurs d'horodatage :

W-timestamp(X) : Le plus grand horodatage de toute transaction qui a écrit avec succès X.
R-timestamp(X) : Le plus grand horodatage de toute transaction qui a lu avec succès X.

Pour une transaction T essayant de lire X :

Si TS(T) < W-timestamp(X), T est trop tard et doit être annulée et redémarrée.
Sinon, autoriser T à lire X et définir R-timestamp(X) sur max(R-timestamp(X), TS(T)).

Pour une transaction T essayant d'écrire X :

Si TS(T) < R-timestamp(X) ou TS(T) < W-timestamp(X), T est trop tard et doit être annulée et redémarrée.
Sinon, autoriser T à écrire X et définir W-timestamp(X) sur TS(T).

Voyons un exemple :

class DataItem:
def __init__(self):
self.value = None
self.r_timestamp = 0
self.w_timestamp = 0

def read(transaction, data_item):
if transaction.timestamp < data_item.w_timestamp:
print(f"Transaction {transaction.id} est trop tard pour lire. Annulation...")
abort(transaction)
else:
print(f"Transaction {transaction.id} lit la valeur : {data_item.value}")
data_item.r_timestamp = max(data_item.r_timestamp, transaction.timestamp)

def write(transaction, data_item, new_value):
if (transaction.timestamp < data_item.r_timestamp or
transaction.timestamp < data_item.w_timestamp):
print(f"Transaction {transaction.id} est trop tard pour écrire. Annulation...")
abort(transaction)
else:
print(f"Transaction {transaction.id} écrit la valeur : {new_value}")
data_item.value = new_value
data_item.w_timestamp = transaction.timestamp

def abort(transaction):
print(f"Transaction {transaction.id} annulée et sera redémarrée.")

Dans cet exemple, nous avons implémenté des opérations de lecture et d'écriture de base suivant le protocole d'ordre par horodatage. Le système vérifie les horodatages avant d'autoriser les opérations et les met à jour en conséquence.

Règle d'Écriture de Thomas : Une Optimisation Intelligente

La Règle d'Écriture de Thomas est comme permettre à un coureur plus rapide de dépasser un coureur plus lent dans une course. Elle nous permet d'ignorer certaines écritures "trop tard" sans annuler la transaction.

Voici comment cela fonctionne :

Si TS(T) < W-timestamp(X), au lieu d'annuler T, nous ignorons simplement cette opération d'écriture. C'est sûr car la valeur écrite est de toute façon obsolète.

Modifions notre fonction write pour inclure la Règle d'Écriture de Thomas :

def write_with_thomas_rule(transaction, data_item, new_value):
if transaction.timestamp < data_item.r_timestamp:
print(f"Transaction {transaction.id} est trop tard pour écrire. Annulation...")
abort(transaction)
elif transaction.timestamp < data_item.w_timestamp:
print(f"Transaction {transaction.id} ignore l'écriture selon la Règle d'Écriture de Thomas.")
else:
print(f"Transaction {transaction.id} écrit la valeur : {new_value}")
data_item.value = new_value
data_item.w_timestamp = transaction.timestamp

Cette optimisation aide à réduire le nombre d'annulations de transactions inutiles, améliorant ainsi les performances globales du système.

Conclusion

Whaou ! Nous avons couvert beaucoup de terrain aujourd'hui, des protocoles basés sur les verrous aux protocoles basés sur les horodatages. Souviens-toi, le contrôle de concurrency est tout à fait nécessaire pour maintenir l'ordre dans le monde chaotique des opérations de base de données simultanées. C'est comme être un policier de la circulation à un carrefour occupé, assurant que tout le monde arrive à destination sans accident.

Comme vous continuez votre voyage dans le monde des bases de données, vous rencontrerez des concepts et des techniques plus avancés. Mais pour l'instant, félicitez-vous pour avoir maîtrisé ces concepts fondamentaux du contrôle de concurrency !

Continuez à pratiquer, restez curieux, et bon codage !

Credits: Image by storyset