Apakah yang menyebabkan deadlock dan bagaimana anda mencegahnya?

Question

Accepted Answer

Sebuah **deadlock** berlaku apabila dua (atau lebih) transaksi masing-masing memegang lock yang diperlukan oleh yang lain, jadi tiada satu pun boleh meneruskan — mereka tersekat menunggu antara satu sama lain selama-lamanya. Pangkalan data mengesan deadlock dan menyelesaikannya dengan **membatalkan satu transaksi** ("mangsa"), yang mesti dicuba semula. Memahami punca dan pencegahannya penting untuk aplikasi serentak.

## Bagaimana deadlock berlaku

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

## Bagaimana pangkalan data mengendalikan deadlock

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

## Strategi pencegahan

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

**Pencegahan #1** ialah **susunan lock yang konsisten**: jika semua transaksi memperoleh lock dalam susunan yang sama (cth. sentiasa id yang lebih rendah dahulu), penantian berkitar tidak dapat terbentuk.

## Corak cuba semula (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.
```

## Mengapa ia penting

Deadlock ialah isu keserentakan yang penting dalam pangkalan data — ia berlaku dalam mana-mana aplikasi dengan transaksi serentak yang mengubah suai data yang bertindih, dan memahaminya merupakan pengetahuan peringkat senior yang bernilai untuk membina sistem serentak yang teguh.

Memahami **punca** — dua transaksi masing-masing memegang lock yang diperlukan oleh yang lain, mencipta penantian berkitar di mana tiada satu pun boleh meneruskan — ialah asasnya.

Mengetahui cara pangkalan data **mengendalikan** deadlock (mengesan kitaran dan membatalkan satu transaksi sebagai mangsa, yang mesti dicuba semula) adalah penting kerana ia bermakna **aplikasi anda mesti mengendalikan ralat deadlock dengan logik cuba semula** — deadlock tidak dapat dihapuskan sepenuhnya, jadi kod serentak yang berdaya tahan menangkap ralat deadlock dan mencuba semula (corak standard yang penting).

**Strategi pencegahan** ialah pengetahuan praktikal utama, terutamanya teknik #1: **susunan lock yang konsisten** (sentiasa memperoleh lock dalam susunan yang sama merentasi semua transaksi, yang memecahkan keadaan penantian berkitar yang menyebabkan deadlock) — bersama-sama dengan memastikan transaksi pendek (memegang lock secara ringkas), mengakses sumber dalam susunan yang konsisten, dan mengelakkan operasi yang panjang dalam transaksi.

Memandangkan deadlock menyebabkan masalah sebenar (transaksi gagal, ralat, prestasi merosot) dalam aplikasi pangkalan data serentak, dan memandangkan memahami puncanya (penantian lock berkitar), pencegahan (terutamanya susunan lock yang konsisten dan transaksi pendek), serta keperluan logik cuba semula yang membolehkan anda membina sistem serentak yang teguh, memahami deadlock adalah pengetahuan peringkat senior yang bernilai untuk mana-mana aplikasi dengan akses pangkalan data serentak yang ketara — kebimbangan operasi yang kerap relevan dan topik temu duga lanjutan yang biasa yang menunjukkan pemahaman tentang keserentakan dan daya tahan pangkalan data.