Two-Phase Commit (2PC)

Also Known As

TL;DR

Explanation

2PC is a consensus protocol: Phase 1 (Prepare) — a coordinator asks all participants to lock resources and vote commit/abort. Phase 2 (Commit/Rollback) — if all voted commit, the coordinator instructs commit; any abort triggers a full rollback. 2PC guarantees ACID atomicity across multiple databases but has significant costs: blocking (if the coordinator crashes after prepare, participants remain locked indefinitely), two network round trips per transaction, and reduced throughput. Most modern distributed systems prefer the Saga pattern for long-lived business transactions and accept eventual consistency rather than paying 2PC's availability and latency costs.

Diagram

sequenceDiagram
    participant COORD as Coordinator
    participant P1 as Participant 1 Orders DB
    participant P2 as Participant 2 Payments DB
    Note over COORD: Phase 1 - Prepare
    COORD->>P1: PREPARE
    COORD->>P2: PREPARE
    P1-->>COORD: VOTE YES
    P2-->>COORD: VOTE YES
    Note over COORD: Phase 2 - Commit
    COORD->>P1: COMMIT
    COORD->>P2: COMMIT
    P1-->>COORD: ACK
    P2-->>COORD: ACK

Common Misconception

Why It Matters

Common Mistakes

• Using 2PC for high-throughput operations — the coordinator is a bottleneck and failure point.
• Not handling coordinator failure — if the coordinator crashes between prepare and commit, participants are blocked.
• Using 2PC when saga or outbox patterns would provide better availability with eventual consistency.
• Not testing the failure path — 2PC rollback code is rarely exercised and often broken.

Code Examples

// Distributed transaction without 2PC — inconsistent state on failure:
function transferFunds(): void {
    $bankA->debit($amount);   // Succeeds
    $bankB->credit($amount);  // Network failure — money lost!
}
// 2PC prepare phase: both banks lock funds
// 2PC commit phase: both banks execute if both prepared successfully
// Rollback phase: both debit/credit reversed if either failed

// 2PC: coordinator asks all participants to PREPARE, then COMMIT
// Ensures atomicity across distributed resources

// PHP example: transfer across two databases
function transfer(PDO \$dbA, PDO \$dbB, int \$amount): void {
    // Phase 1: PREPARE
    \$dbA->beginTransaction();
    \$dbB->beginTransaction();

    try {
        \$dbA->exec("UPDATE accounts SET balance = balance - \$amount WHERE id = 1");
        \$dbB->exec("UPDATE accounts SET balance = balance + \$amount WHERE id = 2");

        // Phase 2: COMMIT both
        \$dbA->commit();
        \$dbB->commit();
    } catch (\Throwable \$e) {
        \$dbA->rollBack();
        \$dbB->rollBack();
        throw \$e;
    }
}

// 2PC is blocking — prefer Saga pattern for long-running distributed transactions

References

• ↗ https://en.wikipedia.org/wiki/Two-phase_commit_protocol

Tags

Related Terms