Mi okozza a holtpontokat és hogyan lehet őket megelőzni?

Question

Accepted Answer

A **holtpont** akkor fordul elő, amikor két (vagy több) tranzakció mindegyike egy zárolást tart, amelyre a másiknak szüksége van, így egyik sem tud haladni – örökké egymásra várnak. Az adatbázisok felismerik a holtpontokat és úgy oldják meg őket, hogy **az egyik tranzakciót abortálják** (az "áldozat"), amelyet aztán újra kell próbálni. Az okok és a megelőzés megértése fontos az egyidejű alkalmazásokhoz.

## Hogyan alakul ki a holtpont

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

## Hogyan kezelik az adatbázisok a holtpontokat

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

## Megelőzési stratégiák

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

A **#1 megelőzési mód** az **konzisztens zárolási sorrend**: ha minden tranzakció ugyanabban a sorrendben szerez zárolásokat (pl. mindig az alacsonyabb azonosító először), az cirkuláris várakozás nem jöhet létre.

## Az újrapróbálkozási minta

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

## Miért számít

A holtpontok fontos egyidejűségi probléma az adatbázisokban – bármilyen alkalmazásban előfordulnak, amely egyidejű tranzakciókat futtat átfedő adatokkal, és megértésük értékes senior szintű tudás a robusztus egyidejű rendszerek felépítéséhez.

Az **ok** megértése – két tranzakció mindegyike egy zárolást tart, amelyre a másiknak szüksége van, olyan cirkuláris várakozást létrehozva, ahol egyik sem tud haladni – az alapvető.

Annak ismerete, hogy az adatbázisok hogyan **kezelik** a holtpontokat (a ciklus felismerése és az egyik tranzakció abortálása "áldozatként", amelyet újra kell próbálni), fontos, mivel azt jelenti, hogy az **alkalmazásnak holtpont hibákat kell kezelnie újrapróbálkozási logikával** – a holtpontok nem küszöbölhetők ki teljesen, így a rugalmas egyidejű kód elkapja a holtpont hibát és újrapróbálkozik (egy standard, fontos minta).

A **megelőzési stratégiák** a kulcsfontosságú gyakorlati tudás, különösen az #1 technika: **konzisztens zárolási sorrend** (mindig ugyanabban a sorrendben szerezve zárolásokat az összes tranzakción keresztül, amely megtöri a cirkuláris várakozási feltételt, amely holtpontokat okoz) – valamint a tranzakciók rövidtartása (zárolások rövid ideig tartása), az erőforrások konzisztens sorrendben elérése és hosszú műveletek elkerülése a tranzakciók között.

Mivel a holtpontok valós problémákat okoznak (sikertelen tranzakciók, hibák, romlott teljesítmény) az egyidejű adatbázis-alkalmazásokban, és mivel azok okának megértése (cirkuláris zárolási várakozás), megelőzésének (különösen konzisztens zárolási sorrend és rövid tranzakciók) és az újrapróbálkozási logika szükségességének megértése az, ami lehetővé teszi robusztus egyidejű rendszerek felépítését, a holtpontok megértése értékes senior szintű tudás bármilyen alkalmazáshoz jelentős egyidejű adatbázis-hozzáféréssel – egy gyakran releváns üzemeltetési szempont és egy közönséges haladó interjúkérdés, amely az adatbázis-egyidejűség és a rugalmasság megértésének demonstrálása.