Apa yang menyebabkan deadlock dan bagaimana cara mencegahnya?

Question

Accepted Answer

Sebuah **deadlock** terjadi ketika dua (atau lebih) transaksi masing-masing menahan kunci yang dibutuhkan oleh yang lain, sehingga tidak ada yang dapat melanjutkan — mereka terjebak menunggu satu sama lain selamanya. Database mendeteksi deadlock dan menyelesaikannya dengan **menggugurkan satu transaksi** ("korban"), yang harus dicoba lagi. Memahami penyebab dan pencegahan adalah penting untuk aplikasi konkuren.

## Cara deadlock terjadi

```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 database menangani 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** adalah **consistent lock ordering**: jika semua transaksi memperoleh kunci dalam urutan yang sama (misalnya selalu id yang lebih rendah terlebih dahulu), tunggu melingkar tidak dapat terbentuk.

## Pola 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 ini penting

Deadlock adalah masalah konkurensi penting dalam database — mereka terjadi di aplikasi apa pun dengan transaksi konkuren yang memodifikasi data yang tumpang tindih, dan memahaminya adalah pengetahuan tingkat senior yang berharga untuk membangun sistem konkuren yang robust.

Memahami **penyebab** — dua transaksi masing-masing menahan kunci yang dibutuhkan oleh yang lain, menciptakan tunggu melingkar di mana tidak ada yang dapat melanjutkan — adalah fondasi.

Mengetahui bagaimana database **menangani** deadlock (mendeteksi siklus dan menggugurkan satu transaksi sebagai korban, yang harus dicoba lagi) adalah penting karena berarti **aplikasi Anda harus menangani kesalahan deadlock dengan logika retry** — deadlock tidak dapat sepenuhnya dihilangkan, jadi kode konkuren yang tahan tangkas menangkap kesalahan deadlock dan mencoba lagi (pola standar dan penting).

**Strategi pencegahan** adalah pengetahuan praktis kunci, terutama teknik #1: **consistent lock ordering** (selalu memperoleh kunci dalam urutan yang sama di semua transaksi, yang memutus kondisi tunggu melingkar yang menyebabkan deadlock) — bersama dengan menjaga transaksi tetap singkat (menahan kunci sebentar), mengakses sumber daya dalam urutan yang konsisten, dan menghindari operasi panjang dalam transaksi.

Karena deadlock menyebabkan masalah nyata (transaksi gagal, kesalahan, kinerja menurun) dalam aplikasi database konkuren, dan karena memahami penyebab mereka (tunggu kunci melingkar), pencegahan (terutama consistent lock ordering dan transaksi pendek), dan kebutuhan logika retry adalah apa yang memungkinkan Anda membangun sistem konkuren yang robust, memahami deadlock adalah pengetahuan tingkat senior yang berharga untuk aplikasi apa pun dengan akses database konkuren yang signifikan — masalah operasional yang sering relevan dan topik wawancara lanjutan umum yang menunjukkan pemahaman tentang konkurensi database dan ketahanan.