Ce cauzeaza interblocajele și cum le previi?

Question

Accepted Answer

Un **interblocare** (deadlock) apare atunci când două (sau mai multe) tranzacții ține fiecare un blocare pe care cealaltă o necesită, așa că nici una nu poate continua — sunt blocate în așteptarea infinită una de cealaltă. Bazele de date detectează interblocajele și le rezolvă prin **abortarea unei tranzacții** ("victima"), care trebuie să se reînceapă. Înțelegerea cauzelor și prevenirii este importantă pentru aplicații concurente.

## Cum apare o interblocare

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

## Cum gestionează bazele de date interblocajele

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

## Strategii de prevenire

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

Prevenirea **#1** este **ordonarea consistentă a blocarilor**: dacă toate tranzacțiile dobândesc blochele în aceeași ordine (de ex. întotdeauna id-ul mai mic întâi), așteptarea circulară nu se poate forma.

## Modelul retry

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

## De ce conteaza

Interblocajele sunt o problemă concurentă importantă în bazele de date — apar în orice aplicație cu tranzacții concurente care modifică date suprapuse, și înțelegerea lor este cunoaștere valoroasă de nivel senior pentru construirea sistemelor concurente robuste.

Înțelegerea **cauzei** — două tranzacții fiecare ținând o blocare pe care cealaltă o necesită, creând o așteptare circulară unde nici una nu poate continua — este fundamentul.

Cunoașterea modului în care bazele de date **gestionează** interblocajele (detectând ciclul și abortând o tranzacție ca victimă, care trebuie să se reînceapă) este importantă pentru că înseamnă că **aplicația dvs. trebuie să gestioneze erorile de interblocare cu logică de retry** — interblocajele nu pot fi eliminate complet, deci codul concurent rezistent prinde eroarea de interblocare și reîncearcă (un model standard, important).

**Strategiile de prevenire** sunt cunoașterea practică cheie, în special tehnica #1: **ordonarea consistentă a blocarilor** (dobândind întotdeauna blochele în aceeași ordine pe toate tranzacțiile, ceea ce rupe condiția de așteptare circulară care cauzeaza interblocajele) — împreună cu păstrarea tranzacțiilor scurte (ținând blochele pe scurt), accesând resursele într-o ordine consistentă, și evitând operații lungi în tranzacții.

Deoarece interblocajele cauzeaza probleme reale (tranzacții eșuate, erori, performanță degradată) în aplicații concurente cu baze de date, și deoarece înțelegerea cauzei lor (așteptări circulare de blocare), prevenire (în special ordonare consistentă a blocarilor și tranzacții scurte), și necesitatea logicii de retry este ceea ce vă permite să construiți sisteme concurente robuste, înțelegerea interblocajelor este cunoaștere valoroasă de nivel senior pentru orice aplicație cu acces concurent semnificativ la baza de date — o problemă operațională frecvent relevantă și un subiect avansat comun în interviuri demonstrând înțelegerea concurenței bazelor de date și rezilienței.