Two-Phase Locking (2PL)

Concrete Example

Two lock modes, one tiny compatibility matrix. The whole of locking semantics reduces to a single sentence: reads don't conflict with reads; writes conflict with everything.

Locks are acquired on demand by the lock manager, automatically, just before a statement touches each item: a read requests S, a write requests X (or upgrades S→X), and if a conflicting lock is held the requester blocks and waits. Consider one transaction that reads items A and B and writes item C:

BEGIN;
SELECT balance FROM accounts WHERE id = 1;                 -- ① read A  → S(A)
SELECT balance FROM accounts WHERE id = 2;                 -- ② read B  → S(B)
UPDATE accounts SET balance = balance - 100 WHERE id = 3;  -- ③ write C → X(C)  ← LOCK POINT
COMMIT;                                                     -- ④

The acquisitions S(A), S(B), X(C) form the growing phase; X(C) is the lock point — the peak where all locks are held. The four 2PL variants acquire exactly the same locks; they differ only in when those locks release. That single knob — how long you hold before releasing — trades concurrency against anomalies and deadlocks:

Reading the same trace under each variant, written as the lock-held profile over time (each cell ① ② ③ ④ is one statement):

Basic 2PL     ▁▂▃███▁▁▁   release after lock point, even pre-commit
Strict 2PL    ▁▂▃███▃▃▃   S(A),S(B) early; X(C) held until COMMIT
SS2PL         ▁▂▃██████   release nothing early; all drop at COMMIT
Conservative  █████████   acquire S(A),S(B),X(C) all at BEGIN

Basic 2PL may release X(C) before COMMIT — if another transaction reads C in that window and this one then aborts, that is a dirty read plus a cascading abort. Strict 2PL releases the read locks early but pins X(C) to commit, so no one reads uncommitted writes. SS2PL — what real systems including Postgres use — holds everything to commit, so locks only ever grow until commit then all drop together: the simplest model to reason about. Conservative 2PL grabs the entire set at BEGIN, blocking until all are free, which makes it the only deadlock-free variant (never waits while holding a lock) at the cost of having to predeclare every lock.

Visual Model

Picture a buffet with a strict rule: once you put a plate back, you can't pick up a new one. The growing phase is collecting every dish you'll need (each one exclusive while you hold it, so others queue behind you). The lock point is the instant you set your first plate down — from then on you can only return plates. It works because everyone must collect-all-then-return, so you can line people up by when they stopped collecting; no two can each claim they went first on different dishes. Strict 2PL adds one clause: hold your dirty plates (write locks) until you've paid and left (commit), so nobody eats off your unfinished plate.

Step through the lock-count mountain below. The line rises through the growing phase (S(A), S(B), X(C)) to the labelled lock point, then falls in the shrinking phase. Watch where Basic 2PL drops the write lock early versus where Strict 2PL holds it all the way to commit.