Bagaimana cara kerja locking di PostgreSQL?

Question

Accepted Answer

PostgreSQL menggunakan **locks** untuk mengkoordinasikan akses bersamaan dan mencegah konflik. Berkat **MVCC**, pembacaan umumnya tidak memerlukan locks (pembaca tidak memblokir penulis), tetapi penulisan mengakuisisi row-level locks, dan berbagai tipe lock mengkoordinasikan operasi. Memahami locking membantu menghindari contention dan deadlocks.

## MVCC berarti pembacaan biasanya tidak melakukan lock

```text
Because of MVCC, plain SELECTs do NOT take row locks — they read a consistent snapshot.
→ Readers don't block writers, writers don't block readers (a key Postgres advantage).
Locking mainly comes into play for WRITES and explicit locking.
```

## Row-level locks (dari penulisan dan locking eksplisit)

```sql
-- UPDATE/DELETE automatically lock the affected ROWS (until the transaction ends)
UPDATE accounts SET balance = balance - 100 WHERE id = 1;   -- locks row 1

-- SELECT ... FOR UPDATE — explicitly lock rows you intend to update (prevent races)
BEGIN;
SELECT * FROM accounts WHERE id = 1 FOR UPDATE;   -- lock the row
-- ... compute, then UPDATE — no other transaction can modify it meanwhile
UPDATE accounts SET balance = ... WHERE id = 1;
COMMIT;
```

`SELECT ... FOR UPDATE` melakukan lock pada baris sehingga transaksi bersamaan tidak dapat memodifikasinya — mencegah race conditions dalam operasi read-modify-write (misalnya mengurangi inventory dengan aman).

## Tipe lock dan table locks

```text
ROW-level → ACCESS via UPDATE/DELETE/SELECT FOR UPDATE — fine-grained
TABLE-level → some DDL (ALTER TABLE) takes heavier table locks → can block queries
→ Schema changes on busy tables can cause contention; plan migrations carefully
  (Postgres has gotten better — many ALTERs are now non-blocking, but not all).
```

## Menghindari masalah lock dan deadlocks

```text
✓ Keep transactions SHORT (hold locks briefly → less contention)
✓ Acquire locks in a CONSISTENT ORDER across transactions → avoid DEADLOCKS
✓ Use FOR UPDATE deliberately for read-modify-write; consider FOR UPDATE SKIP LOCKED
  for queue-like patterns (skip already-locked rows)
✓ Watch for long-held locks blocking others (pg_locks, pg_stat_activity to diagnose)
✓ Be cautious with DDL on busy tables (can block)
```

## Mengapa ini penting

Memahami locking PostgreSQL penting untuk membangun **aplikasi bersamaan yang benar dan performan**, sehingga ini adalah pengetahuan level senior yang berharga untuk sistem dengan akses database bersamaan yang signifikan.

Wawasan fundamental adalah bahwa **MVCC berarti pembacaan biasanya tidak melakukan lock** (pembaca tidak memblokir penulis — keuntungan concurrency kunci Postgres), jadi locking terutama menyangkut **penulisan dan locking eksplisit**.

Memahami **row-level locks** (diakuisisi oleh UPDATE/DELETE) dan terutama **`SELECT ... FOR UPDATE`** (secara eksplisit melakukan lock pada baris untuk mencegah race conditions dalam operasi read-modify-write — seperti mengurangi inventory atau memproses balance dengan aman, di mana tanpa locking transaksi bersamaan dapat menyebabkan hasil yang tidak benar) penting untuk **kebenaran** dalam skenario bersamaan.

Mengetahui bahwa **perubahan DDL/schema dapat mengambil table locks yang lebih berat** (berpotensi memblokir query pada tabel yang sibuk — pertimbangan penting saat merencanakan migrasi, meskipun Postgres telah meningkatkan banyak ALTER menjadi non-blocking) membantu menghindari contention selama deployment.

Memahami cara **menghindari masalah lock dan deadlocks** — menjaga transaksi tetap singkat (memegang locks sebentar), mengakuisisi locks dalam urutan konsisten (mencegah deadlocks), menggunakan `FOR UPDATE` secara deliberate (dan `SKIP LOCKED` untuk queue patterns), dan mendiagnosis lock contention (pg_locks, pg_stat_activity) — berharga untuk performa dan keandalan dalam concurrency.

Karena concurrency melekat dalam aplikasi nyata, dan karena penggunaan proper locking (terutama `FOR UPDATE` untuk kebenaran dalam operasi read-modify-write, dan menghindari contention/deadlocks) adalah apa yang membuat kode database bersamaan benar dan performan, memahami PostgreSQL locking — model MVCC-no-read-locks, explicit row locking untuk kebenaran, table locks dari DDL, dan menghindari deadlocks/contention — adalah pengetahuan level senior yang berharga untuk membangun aplikasi bersamaan yang robust dan mengoperasikan Postgres di bawah beban, perhatian yang relevan secara sering yang menunjukkan pemahaman tentang kontrol concurrency database.