Why does classic Two-Phase Commit (2PC) suffer from the Coordinator Blocking Problem, and how does 3PC attempt to address it?

In classic Two-Phase Commit (2PC, Gray 1978), a transaction coordinator coordinates commit across multiple resource managers (participants) through Phase 1 (Prepare / Vote-Commit) and Phase 2 (Commit or Abort). The fundamental flaw is synchronous coordinator blocking: if all participants vote "YES" in Phase 1 and enter the PREPARED state, they must hold local database locks and WAIT for the coordinator's Phase 2 decision. If the coordinator crashes or is partitioned from the network during this critical window, the participants CANNOT independently decide whether to commit or abort (because the coordinator might have sent "commit" to one node and crashed before reaching the others). Holding locks indefinitely blocks other transactions and can cascade into cluster-wide deadlock. Skeen's Three-Phase Commit (3PC) introduces an intermediate state (PRE-COMMIT) and a non-blocking timeout protocol: if a participant times out while waiting for the coordinator, participants can elect a new coordinator and safely decide to commit if everyone reached Pre-Commit. However, 3PC requires a synchronous network model (bounded delay) and fails under arbitrary asynchronous network partitions (split-brain).

How does Google Percolator (and PingCAP TiKV) implement decentralized Two-Phase Commit without a single point of failure coordinator?

Google Percolator (Peng & Dabek 2010) builds decentralized, distributed ACID transactions with Snapshot Isolation on top of Bigtable (or TiKV key-value stores) using a two-phase protocol that designates one key as the Primary Lock. In Prewrite Phase: the client selects a start timestamp (start_ts) from a centralized Timestamp Oracle (TSO). The client designates one mutation key as the primary lock and writes a lock record containing the primary key address and start_ts. Then, it writes secondary locks on all other mutated keys, pointing their lock references directly to the primary key. In Commit Phase: the client gets a commit timestamp (commit_ts) from the TSO and attempts to commit ONLY the primary key by replacing the primary lock with a commit record at commit_ts. Once the primary key is committed, the transaction is GUARANTEED to be committed! Secondary keys can be committed asynchronously or lazily resolved by concurrent readers following the pointer to the primary key.

How does Percolator resolve dangling locks when a client crashes midway through a transaction?

If a client crashes after prewriting keys or before finishing the commit phase, it leaves orphaned lock records in the key-value store. When another transaction encounters a locked key, it checks the lock's primary key pointer: (1) If the primary lock still exists and has not expired (checked via client lease / TTL in ZooKeeper or etcd), the reader waits or back-offs; (2) If the primary key has already been committed (a commit record exists at commit_ts >= start_ts), the reader lazily rolls forward the secondary key by clearing the lock and writing the commit record; (3) If the primary lock has expired or has been rolled back, the reader rolls back the transaction by deleting the secondary lock and writing a rollback marker to prevent late writes.

What is the relationship between Percolator and Multi-Version Concurrency Control (MVCC)?

Percolator stores data in three separate MVCC columnar CFs (Column Families): (1) data: stores raw values keyed by (user_key, start_ts); (2) lock: stores active locks keyed by user_key containing (primary_lock_ptr, start_ts, TTL); (3) write: stores commit metadata keyed by (user_key, commit_ts) pointing to the corresponding start_ts. When a read query executes at read_ts, it scans the write CF for the highest commit_ts <= read_ts. Because writes only append new versions with monotonically increasing timestamps from the TSO, reads never block writes and writes never block reads, achieving standard Snapshot Isolation (SI) without read locks.

Distributed Transactions: 2PC, 3PC & Percolator Snapshot Isolation Studio

Verified Specification | Standardized Formulas | Instant Precision

Secure & Private (Zero Data Retention) Free Access • No Sign-Up

Distributed Transactions: 2PC, 3PC & Percolator Studio

Compare classic Two-Phase Commit coordinator locking against decentralized Google Percolator (TiKV) Snapshot Isolation with primary locks and lazy resolution.

Protocol Engine:

Prewriting

Transaction State

101

Start Timestamp (start_ts)

Pending

Commit Timestamp (commit_ts)

1 Primary, 2 Secondary

Active MVCC Lock Records

Percolator MVCC Column Families (data, lock, write)

Blue = Active Lock | Green = Committed Write Version

Key: "account:A" Primary Key

CF	Key @ TS	Value
data	account:A @ 101	$4,500
lock	account:A	PrimaryLock (ts=101)

Key: "account:B" Secondary Key

CF	Key @ TS	Value
data	account:B @ 101	$5,500
lock	account:B	Ptr → account:A

Key: "audit:log_9" Secondary Key

CF	Key @ TS	Value
data	audit:log_9 @ 101	TxTransferOK
lock	audit:log_9	Ptr → account:A

Transaction Execution Event Stream

[TSO] Timestamp Oracle allocated start_ts = 101. Prewrite phase initialized.

Distributed Transactions: 2PC, 3PC & Percolator Studio

Percolator MVCC Column Families (data, lock, write)

Transaction Execution Event Stream

Production Percolator / TiKV Code

🔍 Companion Workbenches & Verification Tools

Linux Permissions & Chmod Calculator

Linux WireGuard Cryptokey Routing Studio | AllowedIPs LPM Radix Trie Architecture

Unix Timestamp & Epoch Converter

Linux Kernel Slab Allocator & Free List Hardening Studio | Heap Exploitation Mitigations

Why Smart Users Are Switching to This Free Toolkit

The Browser Feature Most People Never Use

Stop Paying for Software You Can Get Free

File Conversion Tricks That Save Hours Every Week

This Free Tool Replaced 5 Paid Apps for Our Team

What Your Browser Can Do Without Any Extensions