BestHub
Sign in
Tagged articles

two-phase commit

95 articles · Page 1 of 1
Weekly Large Model Application
Weekly Large Model Application
Sep 21, 2026 · Artificial Intelligence

Full-Duplex Voice Agents: When to Commit Parameters? Eager, Conservative, Two-Phase Compared

This article analyzes three commit strategies—Eager, Conservative, and Two-phase—for tool calling in full-duplex voice agents, explaining how each handles user self-correction, side-effect safety, and latency trade-offs, and provides selection guidelines based on operation reversibility.

System DesignTool Callingconservative commit
0 likes · 8 min read
Full-Duplex Voice Agents: When to Commit Parameters? Eager, Conservative, Two-Phase Compared
Dabaoshi
Dabaoshi
Jul 26, 2026 · Databases

Understanding MySQL Binlog and Its Two‑Phase Commit Process

This article explains what MySQL's binary log (binlog) is, how it differs from the redo log, the three binlog formats, the full execution flow of an UPDATE statement, why MySQL uses a two‑phase commit, and how crash recovery ensures data consistency across primary and replica servers.

BinlogMySQLReplication
0 likes · 18 min read
Understanding MySQL Binlog and Its Two‑Phase Commit Process
Lakehouse Research Base
Lakehouse Research Base
Jul 14, 2026 · Big Data

Flink + Paimon End-to-End Exactly-Once: Production Implementation Guide

This guide details how to achieve end-to-end exactly-once semantics with Apache Flink and Apache Paimon, covering consistency models, three-layer coordination mechanisms, production-grade configurations, concurrency rules, verification tests, failure injection scenarios, performance trade-offs, and operational SOPs for lakehouse streaming workloads.

Apache FlinkApache PaimonCheckpoint
0 likes · 26 min read
Flink + Paimon End-to-End Exactly-Once: Production Implementation Guide
Code Farming
Code Farming
Jun 19, 2026 · Backend Development

Nail Distributed Transaction Consistency Questions in Interviews with This Full‑Score Answer

The article explains why reciting the 2PC protocol fails in real‑world interviews, then walks through the two dominant solutions—two‑phase commit and MQ‑based eventual consistency—detailing their mechanisms, trade‑offs, and a concrete interview response template that showcases practical experience and theoretical depth.

Interview Preparationdistributed transactionseventual consistency
0 likes · 6 min read
Nail Distributed Transaction Consistency Questions in Interviews with This Full‑Score Answer
Java Architect Handbook
Java Architect Handbook
Apr 7, 2026 · Databases

Master MySQL’s Redo, Undo, and Binlog: Deep Dive for Interview Success

This article provides a comprehensive interview guide on MySQL’s three core logs—redo log, undo log, and binlog—covering their architecture, roles in crash recovery, MVCC, replication, configuration commands, two‑phase commit workflow, and frequent follow‑up questions to help candidates ace database interview questions.

BinlogDatabase InterviewMySQL
0 likes · 13 min read
Master MySQL’s Redo, Undo, and Binlog: Deep Dive for Interview Success
Java One
Java One
Jul 31, 2025 · Backend Development

Step‑by‑Step Guide to Building Distributed Transactions with Seata and Spring Cloud

This tutorial explains how to ensure data consistency across microservices by implementing distributed transactions with Seata, covering architecture, service implementation, configuration, two‑phase commit protocol, transaction modes, and debugging techniques for a complete end‑to‑end solution.

AT ModeSeataSpring Cloud
0 likes · 25 min read
Step‑by‑Step Guide to Building Distributed Transactions with Seata and Spring Cloud
Cognitive Technology Team
Cognitive Technology Team
Apr 12, 2025 · Backend Development

Implementation Principles of RocketMQ Distributed Transaction Messages

The article explains how RocketMQ implements distributed transaction messages using a two‑phase commit model to ensure data consistency across micro‑service subsystems, detailing the workflow from half‑message production, broker handling, local transaction execution, commit/rollback decisions, and periodic status checks.

RocketMQbackend developmentdistributed transaction
0 likes · 7 min read
Implementation Principles of RocketMQ Distributed Transaction Messages
Su San Talks Tech
Su San Talks Tech
Mar 11, 2025 · Backend Development

7 Proven Retry Strategies to Keep Your System Running Smoothly

This article explores seven practical retry solutions—from simple loops and Spring Retry to Resilience4j, message queues, scheduled tasks, two‑phase commits, and distributed locks—explaining their scenarios, core code, and how they prevent costly system failures.

BackendMQResilience4j
0 likes · 10 min read
7 Proven Retry Strategies to Keep Your System Running Smoothly
Liangxu Linux
Liangxu Linux
Sep 12, 2024 · Databases

Master MySQL Redo Log & Binlog: 15 Essential Interview Questions Explained

Explore 15 classic MySQL log interview questions covering redo log, WAL, binlog, undo log, two‑phase commit, write‑ahead logging, crash‑safe mechanisms, log flushing settings, and recovery procedures, with detailed explanations, execution flow diagrams, and configuration parameters to help you ace database engineering interviews.

BinlogWALdatabase recovery
0 likes · 16 min read
Master MySQL Redo Log & Binlog: 15 Essential Interview Questions Explained
Liangxu Linux
Liangxu Linux
Sep 2, 2024 · Databases

Master MySQL Logs: Redo, Binlog, Undo & Crash‑Safe Mechanisms Explained

This article compiles 15 classic MySQL log interview questions and provides detailed explanations of redo log, WAL, binlog, undo log, two‑phase commit, crash‑safe mechanisms, and related configuration parameters, helping readers understand database recovery and replication fundamentals.

BinlogCrash Safedatabase recovery
0 likes · 17 min read
Master MySQL Logs: Redo, Binlog, Undo & Crash‑Safe Mechanisms Explained
JavaEdge
JavaEdge
Sep 1, 2024 · Backend Development

How Kafka Implements Transactions and Achieves Exactly‑Once Guarantees

This article explains how Kafka implements transactions using a two‑phase commit protocol, compares its approach with RocketMQ, details the exactly‑once semantics for streaming workloads, and walks through the coordinator roles, message flow, and practical use‑case scenarios.

Kafkatransactiontwo-phase commit
0 likes · 10 min read
How Kafka Implements Transactions and Achieves Exactly‑Once Guarantees
Aikesheng Open Source Community
Aikesheng Open Source Community
Apr 24, 2024 · Databases

Summary of the MySQL Transaction Module Series

This article reviews the 14-part series on MySQL's transaction module, covering initialization, transaction types, two‑phase commit, binlog handling, savepoints, and full rollback, and provides links to each detailed post, including discussions on BEGIN statements, read‑only transactions, and the internal mechanisms of InnoDB.

BinlogInnoDBMySQL
0 likes · 5 min read
Summary of the MySQL Transaction Module Series
Nullbody Notes
Nullbody Notes
Jan 30, 2024 · Backend Development

Implementing TCC Distributed Transactions for Redis in Go

This article explains how to build a TCC‑style distributed transaction layer for Redis using Go, detailing the two‑phase commit workflow, handling of prepare, commit, and rollback phases, the associated consistency challenges, and providing full code examples.

RedisTCCbackend development
0 likes · 13 min read
Implementing TCC Distributed Transactions for Redis in Go
ITPUB
ITPUB
May 1, 2023 · Backend Development

Mastering Seata: How Reverse Compensation Powers Distributed Transactions

This article demystifies distributed transactions using Alibaba's Seata, explaining reverse compensation, core concepts (TC, TM, RM), the two‑phase commit protocol, and detailed walkthroughs of AT, TCC, XA, and Saga modes with code examples and step‑by‑step procedures.

AT ModeSAGASeata
0 likes · 14 min read
Mastering Seata: How Reverse Compensation Powers Distributed Transactions
政采云技术
政采云技术
Mar 2, 2023 · Fundamentals

Two‑Phase Commit in Lucene: Mechanism, Implementation, and Rollback

This article explains the two‑phase commit protocol, describes how Lucene implements it through a dedicated interface, details the preparation, commit, segment handling, deletion policies, and rollback procedures, and provides code snippets illustrating the core logic.

Lucenedistributed transactionsrollback
0 likes · 13 min read
Two‑Phase Commit in Lucene: Mechanism, Implementation, and Rollback
政采云技术
政采云技术
Mar 2, 2023 · Databases

Understanding Two-Phase Commit and Its Implementation in Lucene

This article explains the two-phase commit protocol for distributed transactions, details its generic workflow, and describes how Apache Lucene implements the protocol through its TwoPhaseCommit interface, including preparation, flushing, commit, segment handling, deletion policies, and rollback mechanisms with illustrative code examples.

JavaLucenedistributed transactions
0 likes · 12 min read
Understanding Two-Phase Commit and Its Implementation in Lucene
Big Data Technology Architecture
Big Data Technology Architecture
Aug 13, 2022 · Big Data

Apache Doris at Xiaomi: Architecture Evolution, Performance Optimizations, and Production Practices

This article details Xiaomi's three‑year journey of adopting Apache Doris across dozens of internal services, describing the transition from a Spark‑SQL‑based Lambda architecture to a unified MPP database, performance benchmarks, data ingestion pipelines, compaction tuning, two‑phase commit, single‑replica writes, monitoring, and community contributions.

Apache DorisMPPReal‑Time Analytics
0 likes · 19 min read
Apache Doris at Xiaomi: Architecture Evolution, Performance Optimizations, and Production Practices
JavaEdge
JavaEdge
Jan 13, 2022 · Databases

Ensuring Redo Log and Binlog Consistency in InnoDB with Two‑Phase Commit

This article explains how InnoDB’s two‑phase commit mechanism keeps the redo log and binlog logically consistent, illustrating failure scenarios, the impact on data recovery, and how the prepare‑commit split prevents inconsistencies in MySQL’s storage engine.

BinlogInnoDBMySQL
0 likes · 4 min read
Ensuring Redo Log and Binlog Consistency in InnoDB with Two‑Phase Commit
DataFunSummit
DataFunSummit
Nov 22, 2021 · Databases

Rigid Transactions: Two-Phase Commit (2PC) and Three-Phase Commit (3PC) Explained

This article explains rigid (strong consistency) distributed transactions, detailing the XA protocol and the classic two‑phase commit (2PC) and three‑phase commit (3PC) mechanisms, their workflows, advantages, limitations, and practical considerations for database systems.

XA protocoldatabase consistencydistributed transactions
0 likes · 15 min read
Rigid Transactions: Two-Phase Commit (2PC) and Three-Phase Commit (3PC) Explained
Architecture Digest
Architecture Digest
Sep 21, 2021 · Fundamentals

Classic Solutions for Distributed Transactions: Theory and Practical Patterns

This article introduces the fundamental concepts of distributed transactions, explains ACID and BASE properties, and systematically presents classic solutions such as two‑phase commit, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and sub‑transaction barriers for reliable microservice architectures.

SAGATCCdistributed transactions
0 likes · 16 min read
Classic Solutions for Distributed Transactions: Theory and Practical Patterns
vivo Internet Technology
vivo Internet Technology
Sep 15, 2021 · Databases

Percolator Distributed Transaction Architecture and Its Implementation in TiKV

Percolator implements a two‑phase commit transaction protocol with a client coordinator, a timestamp oracle, and storage (Bigtable or TiKV’s RocksDB), providing snapshot‑isolated ACID semantics via lock, write, and data columns; TiKV adds parallel prewrite, short‑value storage, point‑read shortcuts, calculated commit timestamps, and single‑region one‑phase commits to boost performance while keeping the design simple and scalable, though high contention can cause retries and read‑wait delays.

PercolatorRocksDBTiKV
0 likes · 20 min read
Percolator Distributed Transaction Architecture and Its Implementation in TiKV
Architects' Tech Alliance
Architects' Tech Alliance
Jul 18, 2021 · Fundamentals

Fundamentals of Distributed Systems: Concepts, Replication, Consistency, and Core Protocols

This article provides a comprehensive overview of distributed system fundamentals, covering system models, replicas, performance and availability metrics, data distribution strategies, replica protocols such as lease, quorum, two‑phase commit, MVCC, Paxos, and the CAP theorem, with practical engineering considerations.

CAP theoremPaxosReplication
0 likes · 53 min read
Fundamentals of Distributed Systems: Concepts, Replication, Consistency, and Core Protocols
Code Ape Tech Column
Code Ape Tech Column
Jul 13, 2021 · Backend Development

Ensuring Consistent Money Transfers: Distributed Transactions & Message Queues Explained

The article examines how to prevent data inconsistency during cross‑service money transfers by using local transactions, two‑phase commit, and message‑queue based eventual consistency, providing detailed code examples, performance considerations, and practical solutions for large‑scale backend systems.

BackendData ConsistencyRocketMQ
0 likes · 23 min read
Ensuring Consistent Money Transfers: Distributed Transactions & Message Queues Explained
IT Architects Alliance
IT Architects Alliance
Jul 11, 2021 · Backend Development

Understanding Distributed Transactions: Two‑Phase Commit, Message‑Queue Solutions, and RocketMQ Transactional Messaging

This article explains how to guarantee data consistency when updating multiple tables or services by using local transactions for single‑node systems, two‑phase commit for distributed databases, and reliable message‑queue patterns—including RocketMQ transactional messages—to achieve eventual consistency and handle duplicate delivery.

RocketMQTransactional Messagingdatabase consistency
0 likes · 21 min read
Understanding Distributed Transactions: Two‑Phase Commit, Message‑Queue Solutions, and RocketMQ Transactional Messaging
ITPUB
ITPUB
Mar 29, 2021 · Databases

Inside YugabyteDB: Architecture, Tablet Storage, and Distributed Transactions Explained

This article provides a comprehensive technical overview of YugabyteDB, covering its two‑layer logical architecture, tablet‑based distributed storage with Raft groups, RocksDB‑backed local storage design, hybrid hash‑range partitioning, and the MVCC‑based two‑phase‑commit transaction model using Hybrid Logical Clocks.

MVCCRocksDBTablet Storage
0 likes · 15 min read
Inside YugabyteDB: Architecture, Tablet Storage, and Distributed Transactions Explained
IT Architects Alliance
IT Architects Alliance
Mar 7, 2021 · Databases

Mastering Distributed Transactions: From ACID to TCC and Sharding Strategies

This article provides a comprehensive technical guide to distributed transactions, covering ACID fundamentals, consistency models, sharding techniques, CAP and BASE theories, and detailed implementations of two‑phase, three‑phase, and TCC protocols, while highlighting their advantages, limitations, and practical considerations.

BASE theoryCAP theoremTCC
0 likes · 23 min read
Mastering Distributed Transactions: From ACID to TCC and Sharding Strategies
Code Ape Tech Column
Code Ape Tech Column
Feb 25, 2021 · Fundamentals

What Starbucks Can Teach Us About Two-Phase Commit and Asynchronous Messaging

The article uses Starbucks' coffee‑ordering process to illustrate asynchronous order handling, correlation identifiers, exception‑handling strategies, two‑phase commit, and conversation patterns, showing how real‑world practices inform the design of reliable distributed messaging systems.

Asynchronous Messagingcorrelationerror handling
0 likes · 8 min read
What Starbucks Can Teach Us About Two-Phase Commit and Asynchronous Messaging
Top Architect
Top Architect
Jan 4, 2021 · Backend Development

Understanding the Saga Pattern for Distributed Data Consistency in Microservices

This article explains the importance of data consistency in distributed microservice systems, introduces the Saga pattern as a solution, compares it with two‑phase commit and TCC, and details its architecture, recovery mechanisms, and implementation considerations within ServiceComb.

Data ConsistencyTCCdistributed transactions
0 likes · 19 min read
Understanding the Saga Pattern for Distributed Data Consistency in Microservices
Programmer DD
Programmer DD
Nov 4, 2020 · Fundamentals

What Starbucks Can Teach Us About Asynchronous Messaging and Two‑Phase Commit

The article uses Starbucks' coffee‑ordering workflow as a real‑world analogy to explain asynchronous messaging patterns, correlation challenges, exception handling strategies, and why two‑phase commit can hinder scalability, illustrating how everyday processes inspire robust distributed system designs.

Asynchronous Messagingcompensationcorrelation
0 likes · 8 min read
What Starbucks Can Teach Us About Asynchronous Messaging and Two‑Phase Commit
21CTO
21CTO
Aug 5, 2020 · Databases

Understanding Distributed Transactions: 2PC, 3PC, Calvin, Spanner, and More

Distributed transactions require careful coordination to maintain consistency across multiple nodes, and this article explores core concepts such as atomic operations, two‑phase and three‑phase commit protocols, deterministic Calvin ordering, Google Spanner’s TrueTime and Paxos‑based approach, as well as advanced techniques like Percolator, RAMP, and coordination avoidance.

Calvin protocolRAMPSpanner
0 likes · 33 min read
Understanding Distributed Transactions: 2PC, 3PC, Calvin, Spanner, and More
ITPUB
ITPUB
Jul 28, 2020 · Databases

Why MySQL Binlog Can Cause Order Fulfillment Delays and How to Fix It

This article explains MySQL Binlog’s role in event‑driven order processing, analyzes hidden pitfalls such as premature Binlog reads and two‑phase commit issues, and offers practical solutions like retry strategies and direct Binlog consumption to ensure data consistency.

Database LogsMySQLevent-driven architecture
0 likes · 14 min read
Why MySQL Binlog Can Cause Order Fulfillment Delays and How to Fix It
Top Architect
Top Architect
Jul 8, 2020 · Fundamentals

Distributed System Characteristics and Solutions for Distributed Transaction Consistency

This article explains the key characteristics of distributed systems, introduces the CAP and BASE theories, compares strong, weak and eventual consistency models, and reviews common distributed transaction solutions such as two‑phase commit, TCC and message‑based approaches, highlighting their trade‑offs and practical considerations.

BASE theoryCAP theoremTCC
0 likes · 13 min read
Distributed System Characteristics and Solutions for Distributed Transaction Consistency
Alibaba Cloud Developer
Alibaba Cloud Developer
May 28, 2020 · Databases

Mastering Distributed Transactions: 5 Solutions, Patterns, and Their Trade‑offs

This article explains the fundamentals of distributed transactions, compares five major solutions—including XA two‑phase commit, TCC, Saga, message‑based approaches, and maximum‑effort notification—covers their architectures, advantages, drawbacks, and provides guidance on selecting the right model for micro‑service systems.

SAGASeataTCC
0 likes · 27 min read
Mastering Distributed Transactions: 5 Solutions, Patterns, and Their Trade‑offs
vivo Internet Technology
vivo Internet Technology
May 20, 2020 · Databases

Understanding MySQL Crash‑Safe Mechanism: WAL, Redo/Undo/Binlog, Two‑Phase and Group Commit, and Recovery Process

MySQL achieves crash‑safe durability by employing a write‑ahead log architecture that records changes in redo, undo, and binary logs, coordinates them through two‑phase and group commit to maintain order, and uses a structured recovery process to replay or roll back transactions after any failure.

BinlogCrash SafetyGroup Commit
0 likes · 17 min read
Understanding MySQL Crash‑Safe Mechanism: WAL, Redo/Undo/Binlog, Two‑Phase and Group Commit, and Recovery Process
dbaplus Community
dbaplus Community
Mar 8, 2020 · Databases

Why Distributed Databases Need a New Architecture: From Two‑Phase Commit to Raft

This article examines the pressures driving banks to redesign their core database systems, compares three distributed‑access approaches, explains the components of modern distributed databases, analyzes two‑phase and three‑phase commit issues, and evaluates consensus algorithms, CAP/BASE trade‑offs, GTM design, and point‑in‑time recovery.

CAP theoremGTMRaft
0 likes · 19 min read
Why Distributed Databases Need a New Architecture: From Two‑Phase Commit to Raft
AntTech
AntTech
Oct 7, 2019 · Databases

OceanBase TPC‑C Benchmark: Transaction Engine Design and ACID Guarantees

OceanBase’s TPC‑C benchmark demonstrates how its distributed database achieves high durability, atomicity, isolation, and consistency on commodity cloud servers using Paxos‑based log replication, two‑phase commit, MVCC, and replicated tables, highlighting the architectural challenges and solutions for ACID compliance.

ACIDMVCCOceanBase
0 likes · 10 min read
OceanBase TPC‑C Benchmark: Transaction Engine Design and ACID Guarantees
JD Retail Technology
JD Retail Technology
Jul 19, 2019 · Databases

Optimizing Distributed Transactions in CB‑SQL: From Two‑Phase Commit to Parallel and Pipeline Commit

This article explains how CB‑SQL improves distributed transaction performance by introducing a transaction record table, parallel prepare requests, one‑phase commit for single‑shard writes, latch‑based consistent reads, transaction pipelines, and a staged parallel‑commit mode, dramatically reducing latency and I/O overhead.

CB-SQLDatabase OptimizationLatch
0 likes · 13 min read
Optimizing Distributed Transactions in CB‑SQL: From Two‑Phase Commit to Parallel and Pipeline Commit
Big Data Technology & Architecture
Big Data Technology & Architecture
May 19, 2019 · Big Data

Implementing End-to-End Exactly-Once Semantics in Apache Flink with Apache Kafka Using Two-Phase Commit Sink

This article explains how Apache Flink’s TwoPhaseCommitSinkFunction, introduced in version 1.4, enables end-to-end exactly-once semantics when integrated with Apache Kafka, detailing the checkpoint mechanism and the two-phase commit protocol that ensures reliable data processing.

Apache FlinkApache Kafkabig data
0 likes · 4 min read
Implementing End-to-End Exactly-Once Semantics in Apache Flink with Apache Kafka Using Two-Phase Commit Sink
dbaplus Community
dbaplus Community
Nov 5, 2018 · Databases

Why Distributed Transactions Matter: From CAP to Saga and Beyond

This article explains why transactions are essential, traces their origin from early XA specifications, examines the CAP and BASE theories that expose challenges in distributed systems, and reviews practical solutions such as two‑phase commit, three‑phase commit, TCC, asynchronous messaging, Saga and Gossip protocols, highlighting their trade‑offs and when to apply each.

BASE theoryCAP theoremSaga Pattern
0 likes · 17 min read
Why Distributed Transactions Matter: From CAP to Saga and Beyond
JD Tech
JD Tech
Jul 16, 2018 · Databases

Vitess Two-Phase Commit: Concepts, Implementation, and Exception Handling

This article explains Vitess’s two‑phase commit mechanism for distributed transactions, covering the ACID properties, shard architecture, transaction manager roles, detailed code flow, metadata handling, preparation, commit, rollback, and various failure scenarios, along with practical examples and performance considerations.

GoVitesstwo-phase commit
0 likes · 25 min read
Vitess Two-Phase Commit: Concepts, Implementation, and Exception Handling
AntTech
AntTech
May 28, 2018 · Databases

Understanding Distributed Transactions: Concepts, XA Protocol, and TCC Model

This article introduces the fundamentals of distributed transactions, explains the ACID properties of transactions, compares local and distributed transaction architectures, and provides detailed analyses of two common distributed transaction models—X/Open XA and TCC—including their atomicity, isolation, consistency mechanisms and practical trade‑offs.

ACIDTCC-modelXA protocol
0 likes · 20 min read
Understanding Distributed Transactions: Concepts, XA Protocol, and TCC Model
Architecture Digest
Architecture Digest
May 20, 2018 · Backend Development

Understanding Distributed Transactions and the XA Two‑Phase Commit Protocol

The article explains how distributed transactions work in microservice architectures, using inventory‑order examples and a World of Warcraft raid analogy to illustrate the XA two‑phase commit protocol, its normal and failure flows, limitations, and alternative approaches such as three‑phase commit, message‑queue and TCC transactions.

XA protocolconsistencydistributed transactions
0 likes · 7 min read
Understanding Distributed Transactions and the XA Two‑Phase Commit Protocol
Qunar Tech Salon
Qunar Tech Salon
Nov 14, 2017 · Backend Development

Designing Distributed Systems Inspired by McDonald’s Restaurant Operations

The article uses everyday observations from a McDonald’s restaurant to illustrate core distributed system concepts such as master‑slave architecture, two‑phase commit, microservice decomposition, task queues, and container orchestration, showing how these principles apply to backend engineering.

CassandraHBaseMaster‑Slave
0 likes · 15 min read
Designing Distributed Systems Inspired by McDonald’s Restaurant Operations
21CTO
21CTO
Sep 29, 2017 · Databases

Ensuring Distributed Consistency: From Local Transactions to Two‑Phase Commit

The article examines how to achieve data consistency in distributed internet systems by comparing strong and eventual consistency, detailing local database transactions, two‑phase commit protocols, rollback mechanisms, local message tables, and compensation strategies, and discusses their trade‑offs and suitable application scenarios.

compensationdistributed transactionslocal message table
0 likes · 11 min read
Ensuring Distributed Consistency: From Local Transactions to Two‑Phase Commit
Architecture Digest
Architecture Digest
Sep 29, 2017 · Databases

Ensuring Consistency in Distributed Systems: From Local Transactions to Two‑Phase Commit and Compensation Mechanisms

This article examines various consistency solutions for distributed systems, including strong and eventual consistency, local database transactions, two‑phase commit, TCC, rollback mechanisms, local message tables, and compensation techniques, illustrating their trade‑offs and appropriate application scenarios.

Transactionscompensationconsistency
0 likes · 13 min read
Ensuring Consistency in Distributed Systems: From Local Transactions to Two‑Phase Commit and Compensation Mechanisms
dbaplus Community
dbaplus Community
Apr 16, 2017 · Backend Development

Ensuring Data Consistency with Distributed Transactions: From Single DB to TCC

This article walks through the evolution of distributed transaction architectures—from simple single-database transactions, through post-commit multi-database approaches and two-phase commit, to TCC and eventual-consistency patterns—illustrating each method with game-style purchase examples, diagrams, and practical implementation tips.

TCCeventual consistencytwo-phase commit
0 likes · 15 min read
Ensuring Data Consistency with Distributed Transactions: From Single DB to TCC
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Apr 11, 2017 · Databases

Why High Availability Triggers a Consistency‑Performance Trade‑off in Distributed Databases

The article explains how achieving high availability through data redundancy introduces consistency challenges that in turn affect performance, and it reviews partitioning, mirroring, consistency models, replication architectures, and two/three‑phase commit protocols in distributed systems.

Data ConsistencyReplicationTransaction Processing
0 likes · 18 min read
Why High Availability Triggers a Consistency‑Performance Trade‑off in Distributed Databases
Architecture Digest
Architecture Digest
Apr 1, 2017 · Backend Development

Distributed Consistency and Transactional Messaging Solutions

This article explains the challenges of achieving consistency in distributed systems and presents practical solutions such as two‑phase commit, asynchronous assurance, compensating transactions, message retry mechanisms, idempotent designs, and a custom Redis‑based delayed queue (DelayQ) with a transactional proxy (TMQProxy) to provide reliable transactional messaging.

Message RetryRedis delay queueTransactional Messaging
0 likes · 19 min read
Distributed Consistency and Transactional Messaging Solutions
Architects' Tech Alliance
Architects' Tech Alliance
Dec 22, 2016 · Fundamentals

Fundamentals of Distributed Systems: Consensus, 2PC/3PC, CAP Theorem, and Logical Clocks

This article introduces core distributed‑system concepts—including the definition of consensus, the two‑phase and three‑phase commit protocols, the CAP theorem and its engineering implications, and logical‑clock mechanisms such as Lamport timestamps, vector clocks, and version vectors—explaining their models, challenges, and practical trade‑offs.

CAP theoremConsensusLamport timestamps
0 likes · 21 min read
Fundamentals of Distributed Systems: Consensus, 2PC/3PC, CAP Theorem, and Logical Clocks
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Dec 2, 2016 · Backend Development

Mastering Distributed Transaction Consistency: From CAP to Message‑Based Compensation

This article examines the fundamental challenges of achieving consistency in distributed systems, explains the CAP theorem, compares two‑phase and three‑phase commit protocols, explores XA transactions, and presents practical compensation patterns such as local message tables, non‑transactional and transactional MQ designs, highlighting their trade‑offs and applicability.

CAP theoremdistributed systemseventual consistency
0 likes · 15 min read
Mastering Distributed Transaction Consistency: From CAP to Message‑Based Compensation
Architecture Digest
Architecture Digest
Nov 8, 2016 · Backend Development

Why Replace Distributed Transactions? A Message Queue and State‑Table Solution

The article explains the drawbacks of traditional two‑phase commit distributed transactions—reduced availability, performance, and scalability—and proposes a message‑queue‑plus‑state‑table pattern with idempotent processing to achieve eventual consistency while improving system throughput.

backend architecturedatabase consistencydistributed transactions
0 likes · 7 min read
Why Replace Distributed Transactions? A Message Queue and State‑Table Solution
dbaplus Community
dbaplus Community
May 20, 2016 · Databases

Inside TiKV: MVCC Mechanics and Distributed Transaction Design

This article explains how TiKV implements multi-version concurrency control (MVCC) on top of RocksDB and details its two‑phase commit transaction model, including Prewrite and Commit phases, Percolator‑style optimizations, lock handling, conflict resolution, and garbage‑collection strategies.

Garbage CollectionMVCCPercolator
0 likes · 14 min read
Inside TiKV: MVCC Mechanics and Distributed Transaction Design
Architecture Digest
Architecture Digest
Apr 4, 2016 · Backend Development

Handling Distributed Transactions in Large‑Scale Microservice Systems

The article examines the challenges of distributed transactions in large‑scale microservice architectures and compares three main approaches—traditional two‑phase commit, stateless queue‑based eventual consistency with event sourcing and CQRS, and transaction compensation techniques such as TCC—highlighting their trade‑offs and real‑world examples like Flipkart.

CQRSEvent Sourcingdistributed transactions
0 likes · 8 min read
Handling Distributed Transactions in Large‑Scale Microservice Systems
21CTO
21CTO
Jan 9, 2016 · Backend Development

How Distributed Transactions Keep Money Transfers Consistent Without Locks

This article explains the challenges of ensuring data consistency across multiple databases during operations like Alipay transfers, introduces local and distributed transactions, details the two‑phase commit protocol, and shows how reliable messaging can replace heavyweight distributed transactions for high‑concurrency systems.

Data Consistencybackend developmentdistributed transactions
0 likes · 10 min read
How Distributed Transactions Keep Money Transfers Consistent Without Locks
Architect
Architect
Jan 9, 2016 · Backend Development

Ensuring Data Consistency: Local Transactions, Distributed Two‑Phase Commit, and Message‑Queue Solutions

The article explains how to maintain data consistency when updating related tables by using local transactions for single‑node databases, distributed two‑phase commit for multi‑node systems, and reliable message‑queue patterns—including deduplication techniques—to avoid the performance pitfalls of traditional distributed transactions.

Data Consistencymessage queuetwo-phase commit
0 likes · 10 min read
Ensuring Data Consistency: Local Transactions, Distributed Two‑Phase Commit, and Message‑Queue Solutions
21CTO
21CTO
Sep 10, 2015 · Databases

Keeping Money Transfers Consistent: Local Transactions, 2PC, and Message Queues

To prevent data inconsistencies when transferring funds—like moving money from Alipay to Yu'ebao—the article explores local transactions, the limitations of two-phase commit in distributed systems, and how reliable message queues can achieve eventual consistency without sacrificing performance.

Data Consistencydistributed transactionsmessage queue
0 likes · 11 min read
Keeping Money Transfers Consistent: Local Transactions, 2PC, and Message Queues
21CTO
21CTO
Aug 14, 2015 · Backend Development

Ensuring Data Consistency: From Local Transactions to Distributed 2PC and Message Queues

This article explores how to maintain data consistency across services by using local transactions, two‑phase commit distributed transactions, and reliable message‑queue patterns, illustrating each method with an Alipay‑to‑YuEBao transfer example and discussing their trade‑offs.

Data Consistencydistributed systemsmessage queue
0 likes · 11 min read
Ensuring Data Consistency: From Local Transactions to Distributed 2PC and Message Queues