PostgreSQL માં લૉકિંગ કેવી રીતે કામ કરે છે?

Question

Accepted Answer

PostgreSQL **લૉક્સ** નો ઉપયોગ કરીને સમવર્તી ઍક્સેસને સંકલિત કરે છે અને સંઘર્ષ શોધવાથી બચાય છે. **MVCC** ને કારણે, વાંચવાની કામગીરી સામાન્ય રીતે લૉક્સની જરૂર નથી (વાચકો લેખકોને અવરોધિત કરતા નથી), પરંતુ લખવાની કામગીરી પંક્તિ-સ્તરીય લૉક્સ મેળવે છે, અને વિવિધ લૉક પ્રકારો ક્રિયાકલાપોને સંકલિત કરે છે. લૉકિંગને સમજવાથી સંઘર્ષ અને ડેડલૉક્સ શોધવામાં મદદ મળે છે.

## MVCC એટલે વાંચવાની કામગીરી સામાન્ય રીતે લૉક કરતી નથી

```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.
```

## પંક્તિ-સ્તરીય લૉક્સ (લખવાની કામગીરી અને સ્પષ્ટ લૉકિંગ પરથી)

```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` પંક્તિઓને લૉક કરે છે જથ્થા તે સમવર્તી ધарાધરણ તેમને સંશોધિત કરી શકતા નથી — પંક્તિ-વાંચો-સંશોધન-લખો ક્રિયાકલાપોમાં દોડના શરતોને શોધવાથી બચાય છે (દા.ત., સુરક્ષિત રીતે ઇનવેન્ટરી ઘટાડવી).

## લૉક પ્રકારો અને કોષ્ટક લૉક્સ

```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).
```

## લૉક સમસ્યાઓ અને ડેડલૉક્સ શોધવા

```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 લૉકિંગને સમજવું **સાચી, કર્મક્ષમ સમવર્તી એપ્લીકેશનો બનાવવા** માટે મહત્વપૂર્ણ છે, તેથી તે વરિષ્ઠ-સ્તરીય જ્ઞાન છે સંમતિ સાથે ડેટાબેસ ઍક્સેસ ધરાવતી પદ્ધતિઓ માટે.

મૂળ અંતર્દૃષ્ટિ એ છે કે **MVCC એટલે વાંચવાની કામગીરી સામાન્ય રીતે લૉક કરતી નથી** (વાચકો લેખકોને અવરોધિત કરતા નથી — Postgres સમવર્તીતા લાભ), તેથી લૉકિંગ મુખ્યત્વે **લખવાની કામગીરી અને સ્પષ્ટ લૉકિંગ** વિશે છે.

**પંક્તિ-સ્તરીય લૉક્સ** (UPDATE/DELETE દ્વારા મેળવાયેલ) અને ખાસ કરીને **`SELECT ... FOR UPDATE`** (પંક્તિઓને સ્પષ્ટ રીતે લૉક કરવા, પંક્તિ-વાંચો-સંશોધન-લખો ક્રિયાકલાપોમાં દોડના શરતોને શોધવાથી બચવા — જેમ કે સુરક્ષિત રીતે ઇનવેન્ટરી અથવા શેષ ઘટાડવી, જ્યાં લૉકિંગ વિના સમવર્તી ધારાધરણ ખોટા પરિણામોનું કારણ બની શકે છે) ને સમજવું સમવર્તી પરિસ્થિતિઓમાં **સાચીતા** માટે મહત્વપૂર્ણ છે.

જાણવું કે **DDL/સ્કીમા પરિવર્તનો ભારે કોષ્ટક લૉક્સ લઈ શકે છે** (સંભવતઃ વ્યસ્ત કોષ્ટકો પર પ્રશ્નોને અવરોધિત કરી શકે છે — સ્થાનાંતર આયોજન કરતી વખતે એક મહત્વપૂર્ણ વિચાર, જો કે Postgres ઘણા ALTERs ને બિન-અવરોધક બનાવ્યા છે) તમને સ્થાપનની સમયે સંઘર્ષ શોધવાથી બચાય છે.

**લૉક સમસ્યાઓ અને ડેડલૉક્સ શોધવા** કેવી રીતે સમજવું — ધારાધરણોને ટૂંકું રાખવું (લૉક્સ ટૂંકા સમય માટે ધરાવવું), લૉક્સ સમાન ક્રમમાં મેળવવું (ડેડલૉક્સ શોધવાથી બચવું), `FOR UPDATE` હેતુપૂર્વક વાપરવું (અને `SKIP LOCKED` કતાર પેટર્ન માટે), અને લૉક સંઘર્ષ નિદાન કરવું (pg_locks, pg_stat_activity) — સમવર્તીતા હેઠળ કર્મક્ષમતા અને વિશ્વાસયોગ્યતા માટે મૂલ્યવાન છે.

सમવર્તીતા વાસ્તવિક એપ્લીકેશનોમાં અંતર્ગત હોવાથી, અને લૉકિંગનો યોગ્ય ઉપયોગ (ખાસ કરીને `FOR UPDATE` પંક્તિ-વાંચો-સંશોધન-લખો ક્રિયાકલાપોમાં સાચીતા માટે, અને સંઘર્ષ/ડેડલૉક્સ શોધવાથી બચવું) તે હોવાથી જે સમવર્તી ડેટાબેસ કોડને સાચું અને કર્મક્ષમ બનાવે છે, PostgreSQL લૉકિંગને સમજવું — MVCC-કોઇ-વાંચવાની-લૉક્સ મોડેલ, સાચીતા માટે સ્પષ્ટ પંક્તિ લૉકિંગ, DDL પરથી કોષ્ટક લૉક્સ, અને ડેડલૉક્સ/સંઘર્ષ શોધવાથી બચવું — મજબૂત સમવર્તી એપ્લીકેશનો બનાવવા અને સંમતિ હેઠળ Postgres ચલાવવા માટે વરિષ્ઠ-સ્તરીય જ્ઞાન છે, વારંવાર-સંબંધિત વિચાર જે ડેટાબેસ સમવર્તીતા નિયંત્રણની સમજણને પ્રદર્શિત કરે છે.