Hogyan működik a zárolás a PostgreSQL-ben?

Question

Accepted Answer

A PostgreSQL **zárolásokat** használ az egyidejű hozzáférés koordinálására és az ütközések megelőzésére. Az **MVCC** miatt az olvasások általában nem igényelnek zárolásokat (az olvasók nem blokkolják az írót), de az írások sor szintű zárolásokat szereznek, és különféle zárololástípusok koordinálják a műveleteket. A zárolás megértése segít elkerülni a versengést és a holtpontokat.

## Az MVCC azt jelenti, hogy az olvasások általában nem zárnak

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

## Sor szintű zárolások (írásokból és explicit zárolásból)

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

A `SELECT ... FOR UPDATE` zárol a sorokat, így az egyidejű tranzakciók nem módosíthatják őket — megelőzve a versenyhelyzeteket az olvasás-módosítás-írás műveletekben (pl. a készlet biztonságos csökkentésében).

## Zárololástípusok és tábla szintű zárolások

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

## Zárololási problémák és holtpontok elkerülése

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

## Miért fontos

A PostgreSQL zárolás megértése fontos a **helyes és hatékony egyidejű alkalmazások** építéséhez, ezért értékes senior szintű tudás a jelentős egyidejű adatbázis-hozzáférésű rendszereknél.

Az alapvető felismerés az, hogy az **MVCC azt jelenti, hogy az olvasások általában nem zárnak** (az olvasók nem blokkolják az írót — ez a PostgreSQL egyidejűségi előnyének kulcsa), így a zárolás elsősorban az **írásokra és explicit zárolásra** vonatkozik.

A **sor szintű zárolások** (UPDATE/DELETE által szerzett) és különösen a **`SELECT ... FOR UPDATE`** (explicit sor zárolás az olvasás-módosítás-írás műveletek versenyhelyzetének megelőzésére — például a készlet biztonságos csökkentésére vagy az egyenleg feldolgozására, ahol zárolás nélkül az egyidejű tranzakciók helytelen eredményeket okozhatnak) megértése fontos az **helyesség** szempontjából az egyidejű forgatókönyvekben.

Annak tudása, hogy az **DDL/séma módosítások nagyobb tábla szintű zárolásokat** igényelhetnek (potenciálisan blokkolva a lekérdezéseket a forgalmas táblákon — fontos szempont az áttelepítések tervezésekor, bár a PostgreSQL sok ALTER műveletet már nem blokkolóvá tette) segít elkerülni a versengést az üzembe helyezések során.

Annak megértése, hogy **hogyan lehet elkerülni a zárololási problémákat és holtpontokat** — a tranzakciók rövid megtartása (zárolások rövid időtartama), zárolások konzisztens sorrendben való szerzése (holtpontok megelőzése), `FOR UPDATE` tudatos használata (és `SKIP LOCKED` a sorvédelem mintázatokhoz), valamint a zárololási versengés diagnosztizálása (pg_locks, pg_stat_activity) — értékes a teljesítmény és megbízhatóság szempontjából az egyidejűség alatt.

Mivel az egyidejűség a valós alkalmazások elmaradhatatlan része, és mivel a megfelelő zárolás használata (különösen a `FOR UPDATE` az olvasás-módosítás-írás műveletek helyessége érdekében, és a versengés/holtpontok elkerülése) az, ami az egyidejű adatbázis kódot helyessé és hatékonyabbá teszi, a PostgreSQL zárolás megértése — az MVCC-nincs olvasásos zárolás modell, explicit sor zárolás a helyesség érdekében, tábla zárolások a DDL-ből, és a holtpontok/versengés elkerülése — értékes senior szintű tudás az erőteljes egyidejű alkalmazások építéséhez és a PostgreSQL terhelés alatti működtetéséhez, egy gyakran releváns szempont, amely az adatbázis egyidejűség-szabályozás megértésének nyilvánulata.