PostgreSQL-இல் locking எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

PostgreSQL concurrent access-ஐ coordinate செய்ய மற்றும் conflicts-ஐ தடுக்க **locks**-ஐ பயன்படுத்துகிறது. **MVCC** நன்றி, reads பொதுவாக locks தேவையில்லை (readers writers-ஐ தடுக்காது), ஆனால் writes row-level locks பெறுகிறது, மற்றும் பல்வேறு lock types operations-ஐ coordinate செய்கிறது. Locking-ஐ புரிந்துகொள்வது contention மற்றும் deadlocks-ஐ தவிர்க்க உதவுகிறது.

## MVCC means reads usually don't 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 (from writes and 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 செய்ய முடியாது — race conditions-ஐ read-modify-write operations-இல் தடுக்கிறது (எ.கா. safely decrementing inventory).

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

## Avoiding lock problems and 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 means reads usually don't lock** (readers writers-ஐ தடுக்காது — ஒரு key Postgres concurrency advantage), எனவே locking முதன்மையாக **writes மற்றும் explicit locking**-ஐ பற்றி கவலைப்படுகிறது.

**Row-level locks**-ஐ (UPDATE/DELETE-ஆல் acquired) மற்றும் குறிப்பாக **`SELECT ... FOR UPDATE`**-ஐ (race conditions-ஐ read-modify-write operations-இல் தடுக்க explicitly rows-ஐ lock செய்ய — inventory safely decrement செய்யுதல் அல்லது balance process செய்யுதல் போன்றவை, locking இல்லாமல் concurrent transactions சரியற்ற results cause செய்யக்கூடும்) புரிந்துகொள்வது concurrent scenarios-இல் **correctness**-க்கு முக்கியமாக உள்ளது.

**DDL/schema changes** heavier table locks பெறக்கூடும் என்பதை அறிந்துகொள்வது (potentially blocking queries busy tables-இல் — migrations plan செய்யும்போது ஒரு முக்கியமான பரிசீலனை, though Postgres பல ALTERs-ஐ non-blocking-ஆக improve செய்துள்ளது) deployments-இல் contention-ஐ தவிர்க்க உதவுகிறது.

**Lock problems மற்றும் deadlocks-ஐ தவிர்க்க** எவ்வாறு வேண்டும் என்பதை புரிந்துகொள்வது — transactions-ஐ short வைக்கிறது (locks briefly holding), consistent order-இல் locks acquire செய்கிறது (deadlocks preventing), deliberately `FOR UPDATE` பயன்படுத்துகிறது (மற்றும் queue patterns-க்கு `SKIP LOCKED`) மற்றும் lock contention diagnosing (pg_locks, pg_stat_activity) — performance மற்றும் reliability-க்கு concurrency-க்குள் valuable.

Concurrency real applications-இல் inherent ஆகையால், மற்றும் proper use of locking (especially read-modify-write operations-க்கு correctness-க்கு `FOR UPDATE`, மற்றும் contention/deadlocks avoiding) concurrent database code correct மற்றும் performant என்பதை makes ஆகையால், PostgreSQL locking-ஐ புரிந்துகொள்வது — MVCC-no-read-locks model, explicit row locking correctness-க்கு, DDL-லிருந்து table locks, மற்றும் deadlocks/contention avoiding — robust concurrent applications building மற்றும் Postgres operating under load-க்கு valuable senior-level knowledge, ஒரு frequently-relevant concern database concurrency control understanding demonstrate செய்கிறது.