2.Distributed Transactions

Why transactions become harder across services and data stores, and how 2PC, TCC, Saga, reliable messaging, reconciliation, and best-effort notification address different consistency requirements.

How two-phase commit coordinates atomic commit across transactional resources, and why blocking, coordinator failure, and long-held resources are its main costs.

Application-level distributed transactions using Try, Confirm, and Cancel operations, including reservations, compensation, retries, idempotency, and business-code cost.

How a durable business change and a durable outgoing message are coupled so downstream services can converge through retries and idempotent consumption.

A notification pattern for external or loosely coupled systems using bounded retries, durable result lookup, and reconciliation instead of atomic cross-system commit.

Long-running distributed transactions as a sequence of local transactions plus compensating actions, with orchestration/choreography and isolation trade-offs.

The CanCommit, PreCommit, and DoCommit structure of 3PC, why it was proposed to reduce blocking, and why partitions still make it uncommon in practice.

A conceptual comparison between resource-level two-phase commit and application-level TCC, both of which separate preparation from the final decision.

How to commit business state and an outgoing event in one local database transaction, then asynchronously publish with retries and idempotent consumption.

A compact implementation-oriented view of two-phase commit and XA resource coordination.

An implementation-oriented summary of application-level Try/Confirm/Cancel transactions and their idempotency and compensation requirements.

Using an MQ for retryable notifications while keeping an authoritative query path for receivers that miss or cannot process a callback.

RocketMQ's half-message, local-transaction, commit/rollback, and transaction-check protocol for coupling producer-side local state with message visibility.