PostgreSQL में locking कैसे काम करती है?

Question

Accepted Answer

PostgreSQL समवर्ती पहुँच को coordinate करने और conflicts को रोकने के लिए **locks** का उपयोग करता है। **MVCC** के कारण, reads को आमतौर पर locks की आवश्यकता नहीं होती (readers writers को block नहीं करते), लेकिन writes row-level locks प्राप्त करते हैं, और विभिन्न lock types operations को coordinate करते हैं। locking को समझना contention और deadlocks से बचने में मदद करता है।

## MVCC का मतलब है reads आमतौर पर 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 (writes और explicit locking से)

```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` rows को lock करता है ताकि समवर्ती transactions उन्हें संशोधित न कर सकें — read-modify-write operations में race conditions को रोकता है (जैसे inventory को सुरक्षित रूप से कम करना)।

## Lock types और 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).
```

## Lock समस्याओं और 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)
```

## यह क्यों महत्वपूर्ण है

PostgreSQL locking को समझना **सही, performant समवर्ती applications** बनाने के लिए महत्वपूर्ण है, इसलिए यह महत्वपूर्ण समवर्ती database पहुँच वाले systems के लिए मूल्यवान senior-स्तरीय ज्ञान है।

मौलिक अंतर्दृष्टि यह है कि **MVCC का मतलब है reads आमतौर पर lock नहीं करते** (readers writers को block नहीं करते — एक मुख्य Postgres concurrency लाभ), इसलिए locking मुख्य रूप से **writes और explicit locking** से संबंधित है।

**row-level locks** (UPDATE/DELETE द्वारा प्राप्त) और खासकर **`SELECT ... FOR UPDATE`** (read-modify-write operations में race conditions को रोकने के लिए स्पष्ट रूप से rows को lock करना — जैसे inventory को सुरक्षित रूप से कम करना या एक balance को process करना, जहाँ locking के बिना समवर्ती transactions गलत परिणाम पैदा कर सकती हैं) को समझना समवर्ती परिदृश्यों में **शुद्धता** के लिए महत्वपूर्ण है।

यह जानना कि **DDL/schema changes भारी table locks ले सकते हैं** (व्यस्त tables पर queries को block कर सकते हैं — migrations की योजना बनाते समय एक महत्वपूर्ण विचार, हालाँकि Postgres ने कई ALTERs को non-blocking बनाने में सुधार किया है) deployments के दौरान contention से बचने में मदद करता है।

यह समझना कि **lock समस्याओं और deadlocks से कैसे बचें** — transactions को छोटा रखना (locks को संक्षेप में रखना), locks को consistent order में प्राप्त करना (deadlocks को रोकना), `FOR UPDATE` का सोच-समझकर उपयोग करना (और queue patterns के लिए `SKIP LOCKED`), और lock contention को diagnose करना (pg_locks, pg_stat_activity) — concurrency के तहत performance और reliability के लिए मूल्यवान है।

चूँकि concurrency वास्तविक applications में अंतर्निहित है, और चूँकि locking का उचित उपयोग (खासकर read-modify-write operations में शुद्धता के लिए `FOR UPDATE`, और contention/deadlocks से बचना) ही समवर्ती database code को सही और performant बनाता है, PostgreSQL locking को समझना — MVCC-no-read-locks model, शुद्धता के लिए explicit row locking, DDL से table locks, और deadlocks/contention से बचना — मजबूत समवर्ती applications बनाने और load के तहत Postgres को संचालित करने के लिए मूल्यवान senior-स्तरीय ज्ञान है, एक अक्सर-प्रासंगिक चिंता जो database concurrency control की समझ दर्शाती है।