X'jissobbru d-deadlock u kif tipprevjeniha?

Question

Accepted Answer

A **deadlock** iseħħ meta żewġ (jew aktar) transazzjonijiet kull wieħed imorr lock li l-ieħor jeħtieġ, u saħansħa waħda ma tistax tipproċedi — huma stuck nistennew lil xulxin b'sempiternu. Id-databases jdetektaw id-deadlocks u jsolviwhom billi **jabbortaw transazzjoni waħda** (il-"vittma"), li trid tirpprova. L-għarfien tal-kawżi u l-prevenzjoni huwa importanti għal applikazzjonijiet concurrency.

## Kif iseħħ deadlock

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

## Kif id-databases ittrattaw id-deadlocks

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

## Stratiġiji ta' prevenzjoni

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

Il-**#1 prevenzjoni** hija **consistent lock ordering**: jekk it-transazzjonijiet kollha jakkwistaw locks fl-istess ordni (per eż. dejjem l-id aktar bass l-ewwel), il-circular wait ma tistax tifforma.

## Il-patern ta' 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.
```

## Għaliex huwa importanti

Id-deadlocks huma kwistjoni importanti ta' concurrency fi databases — seħħu fi kwalunkwe applikazzjoni b'transazzjonijiet concurrent li jimmodifikaw data overlapping, u l-għarfien tagħhom huwa valwuri għal għarfien ta' livell senior għad-dell ta' sistemi concurrent robust.

L-għarfien tal-**kawża** — żewġ transazzjonijiet kull wieħed imorr lock li l-ieħor jeħtieġ, jikkreaw circular wait fejn xejn ma tistax tipproċedi — huwa l-funzjoni.

Il-għarfien kif id-databases **jttrattaw** id-deadlocks (jdetektaw il-cycle u jabbortaw transazzjoni waħda bħala vittma, li trid tirpprova) huwa importanti għaliex jissgħodd li l-**applikazzjoni tiegħek trid ittratta l-erruri ta' deadlock b'logic ta' retry** — id-deadlocks ma jistgħux jiġu eliminati kompletament, allura kodiċi resilient concurrent jkaccja l-errur ta' deadlock u jirpprova (patern standard, importanti).
/**stratiġiji ta' prevenzjoni** huma l-għarfien prattiku ewlieni, speċjalment it-teknika #1: **consistent lock ordering** (dejjem jakkwistaw locks fl-istess ordni fuq it-transazzjonijiet kollha, li tkessr il-circular-wait condition li jissobbru d-deadlocks) — flimkien mal-ikeeping ta' transazzjonijiet qasira (imorru locks brevemente), l-aċċess ta' riżorsi f'ordni konsistenti, u l-evitar ta' operazzjonijiet twal ġewwa transazzjonijiet.

Minkejja d-deadlocks isibbew problemi reali (transazzjonijiet falluti, erruri, performanza degradata) fl-applikazzjonijiet ta' database concurrent, u minkejja l-għarfien tal-kawża tagħhom (circular lock waits), prevenzjoni (speċjalment consistent lock ordering u transazzjonijiet qosra), u n-neċessità ta' logic ta' retry huwa l-li jippermettilok tibni sistemi concurrent robust, l-għarfien ta' deadlocks huwa valwuri għal għarfien ta' livell senior għal kwalunkwe applikazzjoni b'aċċess significant ta' database concurrent — kwistjoni operazzjonali frequently-relevant u topik ta' interview avvanzat komuni li juri l-għarfien tal-concurrency ta' database u l-resilience.