PostgreSQL ਵਿੱਚ locking ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

PostgreSQL **locks** ਦੀ ਵਰਤੋਂ ਕਰਕੇ concurrent access ਨੂੰ ਤਾਲਮੇਲ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ conflicts ਨੂੰ ਰੋਕਦਾ ਹੈ। **MVCC** ਦੀ ਬਦੌਲਤ, reads ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ locks ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ (readers writers ਨੂੰ block ਨਹੀਂ ਕਰਦੇ), ਪਰ writes row-level locks ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ, ਅਤੇ ਵੱਖ-ਵੱਖ lock types operations ਨੂੰ ਤਾਲਮੇਲ ਬਣਾਉਂਦੇ ਹਨ। 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 ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ concurrent transactions ਉਹਨਾਂ ਨੂੰ modify ਨਾ ਸਕਣ — 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 problems ਅਤੇ 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 ਨੂੰ ਸਮਝਨਾ **correct, performant concurrent applications** ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਇਸ ਲਈ ਇਹ significant concurrent database access ਵਾਲੇ systems ਲਈ valuable senior-level knowledge ਹੈ।

ਬੁਨਿਆਦੀ insight ਇਹ ਹੈ ਕਿ **MVCC ਦਾ ਮਤਲਬ ਹੈ ਕਿ reads ਆਮ ਤੌਰ 'ਤੇ lock ਨਹੀਂ ਕਰਦੇ** (readers writers ਨੂੰ block ਨਹੀਂ ਕਰਦੇ — ਇਹ Postgres concurrency ਦੀ ਕੁੰਜੀ ਫਾਇਦਾ ਹੈ), ਇਸ ਲਈ locking ਬਾਵਲ ਤੌਰ 'ਤੇ **writes ਅਤੇ explicit locking** ਬਾਰੇ ਹੈ।

**Row-level locks** (UPDATE/DELETE ਦੁਆਰਾ ਪ੍ਰਾਪਤ) ਅਤੇ ਖਾਸ ਤੌਰ 'ਤੇ **`SELECT ... FOR UPDATE`** (explicitly rows ਨੂੰ lock ਕਰਨਾ ਤਾਂ ਜੋ read-modify-write operations ਵਿੱਚ race conditions ਨੂੰ ਰੋਕਿਆ ਜਾ ਸਕੇ — ਜਿਵੇਂ ਸੁਰੱਖਿਤ ਤੌਰ 'ਤੇ inventory ਨੂੰ ਘਟਾਉਣਾ ਜਾਂ balance ਨੂੰ process ਕਰਨਾ, ਜਿੱਥੇ locking ਤੋਂ ਬਿਨਾਂ concurrent transactions ਗਲਤ ਨਤੀਜੇ ਲਿਆ ਸਕਦੇ ਹਨ) ਨੂੰ ਸਮਝਨਾ concurrent scenarios ਵਿੱਚ **correctness** ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਇਹ ਜਾਣਨਾ ਕਿ **DDL/schema changes ਵਿਚਲੀਆਂ heavier table locks** (ਸੰਭਵ ਤੌਰ 'ਤੇ busy tables 'ਤੇ queries ਨੂੰ block ਕਰ ਸਕਦੀਆਂ ਹਨ — migrations ਦੀ ਯੋਜਨਾ ਬਣਾਉਂਦੇ ਸਮੇਂ ਇਹ ਮਹੱਤਵਪੂਰਨ ਵਿਚਾਰ ਹੈ, ਹਾਲਾਂਕਿ Postgres ਨੇ ਬਹੁਤ ALTERs ਨੂੰ non-blocking ਬਣਾ ਦਿੱਤਾ ਹੈ) deployments ਦੌਰਾਨ contention ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

**Lock problems ਅਤੇ deadlocks ਨੂੰ ਕਿਵੇਂ ਰੋਕਿਆ ਜਾਏ** ਨੂੰ ਸਮਝਣਾ — transactions ਨੂੰ ਛੋਟਾ ਰੱਖਣਾ (locks ਨੂੰ ਥੋੜੇ ਸਮੇਂ ਲਈ ਹੋਲਡ ਕਰਨਾ), locks ਨੂੰ consistent order ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਨਾ (deadlocks ਨੂੰ ਰੋਕਣਾ), `FOR UPDATE` ਦੀ intentional ਵਰਤੋਂ ਕਰਨਾ (ਅਤੇ queue patterns ਲਈ `SKIP LOCKED`) ਅਤੇ lock contention ਨੂੰ diagnose ਕਰਨਾ (pg_locks, pg_stat_activity) — concurrency ਦੌਰਾਨ performance ਅਤੇ reliability ਲਈ valuable ਹੈ।

ਕਿਉਂਕਿ concurrency ਅਸਲ applications ਵਿੱਚ inherent ਹੈ, ਅਤੇ ਕਿਉਂਕਿ locking ਦੀ ਸਹੀ ਵਰਤੋਂ (ਖਾਸ ਤੌਰ 'ਤੇ read-modify-write operations ਵਿੱਚ correctness ਲਈ `FOR UPDATE`, ਅਤੇ contention/deadlocks ਤੋਂ ਬਚਨਾ) ਹੀ ਹੈ ਜੋ concurrent database code ਨੂੰ correct ਅਤੇ performant ਬਣਾਉਂਦਾ ਹੈ, PostgreSQL locking ਨੂੰ ਸਮਝਨਾ — MVCC-no-read-locks model, explicit row locking for correctness, table locks from DDL, ਅਤੇ deadlocks/contention ਨੂੰ ਰੋਕਣਾ — robust concurrent applications ਬਣਾਉਣ ਅਤੇ load ਦੇ ਅਧੀਨ Postgres ਚਲਾਉਣ ਲਈ valuable senior-level knowledge ਹੈ, ਇਹ ਇਕ frequently-relevant concern ਹੈ ਜੋ database concurrency control ਦੀ understanding ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।