This article explains the limitations of single‑database transactions in multi‑data‑source micro‑service scenarios, reviews common distributed‑transaction models such as 2PC, 3PC, TCC, status‑table and message‑queue based final consistency, and details the implementation of Seata's AT mode for achieving global ACID properties.
The fifth episode of the MySQL 冲冲冲 livestream explores the trade‑offs between sharding and middleware architectures, discusses distributed transaction challenges, compares DBLE with MyCat and other solutions, and provides practical guidance for developers and DBAs handling high‑throughput MySQL workloads.
This article explains the fundamentals of database sharding, covering both vertical and horizontal partitioning concepts, routing algorithms, advantages and drawbacks, practical implementation steps using sharding-jdbc, and discusses related challenges such as distributed transactions, pagination, global IDs, and tool selection.
This article explains the essential design principles of a TCC (Try‑Confirm‑Cancel) distributed transaction framework, covering the necessity of RM local transactions, integration with Spring's TransactionManager, fault‑recovery mechanisms, idempotency guarantees, and handling of parallel Try/Confirm/Cancel operations.
The article presents Hmily’s monthly report, detailing its high‑performance distributed transaction solution, recent architectural refactoring, newly added modules and SPI implementations, community‑driven bug fixes and feature releases, and outlines upcoming versions supporting TCC and TAC modes.
Sharding splits a single database into multiple servers to improve performance, covering vertical and horizontal partitioning, middleware options, and key challenges such as distributed transactions, cross‑node joins, ID generation, pagination, routing transparency, and choosing between frameworks or custom solutions.
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.
This article introduces five common distributed transaction patterns—XA two‑phase commit, TCC, local message table, reliable message eventual consistency, and max‑effort notification—explains their principles, advantages, drawbacks, and provides interview questions and suggested answers for each.
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.
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.
The article explains why and when to apply database sharding, describes horizontal and vertical partitioning methods, lists common sharding tools, and discusses challenges such as distributed transactions, join avoidance, pagination, and global primary key generation.
This article objectively compares NewSQL databases with middleware‑based sharding approaches, examining their architectural differences, transaction models, CAP implications, high‑availability designs, scaling mechanisms, storage engines, maturity, and provides a decision guide to help engineers choose the right solution for their workloads.
This article introduces the limitations of traditional local and distributed transactions for microservices, explains the BASE theory, and details four major patterns—reliable event notification, max‑effort notification, business compensation, and TCC—to achieve eventual consistency in microservice architectures.
This article explains the programming mindset of splitting and merging, details MySQL partition implementation and internal file types, demonstrates how partitioning improves query performance, and explores sharding strategies, middleware choices, and common issues like distributed transactions and cross‑shard joins.
This article explores the fundamentals of distributed transactions, comparing traditional two‑phase commit with flexible approaches like reliable‑message eventual consistency, TCC, and best‑effort notification, and provides detailed design patterns, implementation steps, and trade‑offs for building robust backend systems.
This weekly DBLE community newsletter, authored by reporter Yongzheng, compiles curated MySQL and DBLE resources, outlines recent open‑source developments, bug fixes, community Q&A, and upcoming plans for both DBLE and TXLE middleware projects.
The article explains why achieving data consistency across multiple microservices is challenging, reviews the limitations of two‑phase commit, and presents practical techniques such as the Saga pattern, reconciliation, event logs, orchestration vs. choreography, and change‑data‑capture to keep distributed systems eventually consistent.
This comprehensive guide explains the motivations, methods, and trade‑offs of database sharding—including vertical and horizontal partitioning, sharding rules, handling cross‑node joins, distributed transactions, global primary key generation, and practical migration strategies—so you can scale relational databases effectively.
Seata is an open‑source distributed transaction framework designed for microservice architectures, offering high performance and ease of use, with origins in Alibaba’s internal consistency middleware and now commercialized, and the article outlines its AT solution alongside a comprehensive Spring Cloud Alibaba tutorial covering Nacos, Sentinel, and Seata topics.
During Double‑11 2022, Perfect Diary built a micro‑service e‑commerce platform in four months, confronting distributed transactions, database overload, cache pressure, and traffic spikes, and then applied cloud‑native optimizations, rate‑limiting, and pressure testing to achieve record‑breaking sales performance.
This article explains the concepts, benefits, and challenges of database sharding—including vertical and horizontal partitioning, common splitting strategies, handling distributed transactions, cross‑node joins, pagination, global primary keys, and migration—while offering practical guidelines on when to adopt sharding and which tools can assist.
This article walks through setting up Seata for distributed transaction management in a Spring Cloud microservices project, covering concepts of AT, TCC, and Saga modes, configuration of Seata server and clients, code examples for transaction handling, and a practical e‑commerce demo.
This article explains the fundamentals of distributed transactions, compares local and global transaction models, examines protocols like XA and 2PC, introduces flexible transaction patterns such as TCC and compensable operations, and evaluates reliable message‑based solutions for achieving eventual consistency.
This article explains the necessity of distributed transactions in modern systems, introduces the CAP and BASE consistency theories, and reviews practical solutions such as the XA two‑phase commit, TCC compensation model, and message‑queue based eventual consistency approaches.
A recent data platform salon in Beijing gathered five leading experts who shared practical knowledge on data middle platforms, distributed transaction patterns, SQL audit design, Amazon Aurora's architecture, and JD's large‑scale HBase deployment, offering actionable guidance for modern enterprise data engineering.
This article explains Seata’s architecture, core components, and step‑by‑step AT mode workflow—including transaction initiation, branch handling, undo‑log mechanisms, and two‑phase commit/rollback—providing a practical guide for implementing reliable distributed transactions in microservice systems.
This article explains the design and implementation of JDTX, a distributed transaction middleware that combines MVCC, WAL, and a one‑phase commit model to provide strong ACID guarantees, high performance, and multi‑database support while outlining its challenges and future roadmap.
This article introduces JDTX, a high‑performance, ACID‑compliant distributed transaction middleware, explains its architecture based on WAL and MVCC, compares rigid two‑phase commit and flexible BASE‑based approaches, and discusses the technical difficulties and future roadmap for integrating JDTX with Apache ShardingSphere and cloud‑native platforms.
The article explains CB‑SQL's cloud‑native distributed database architecture, covering range‑based sharding, metadata management, hybrid logical clocks, pessimistic distributed transactions with SSI, Raft‑based strong consistency, and horizontal scalability for petabyte‑scale workloads.
This article walks through the complete design of an e‑commerce microservice architecture, covering module identification, domain‑driven design, service splitting, technology stack choices between Dubbo and Spring Cloud, distributed transaction patterns, resilience with Hystrix, centralized configuration, and observability with SkyWalking.
This article objectively compares NewSQL distributed databases with middleware‑based sharding solutions, examining their architectures, distributed transaction handling, scalability, performance, high‑availability, and operational considerations, and provides guidance on selecting the appropriate approach based on workload, consistency, and organizational constraints.
This article explains how Ant Financial tackled cross‑service and cross‑database data‑consistency challenges caused by horizontal sharding and service‑oriented decomposition, introduces its home‑grown distributed‑transaction middleware and the open‑source Seata project with AT, TCC, Saga and XA modes, and shares performance‑optimisation and high‑availability practices.
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.
This article explains the concepts of local and distributed transactions, introduces the CAP theorem, and demonstrates how message‑queue‑based designs with logging and idempotency can ensure data consistency and reliability in distributed banking scenarios.
This article provides a comprehensive analysis of DBLE's XA transaction implementation, covering XA protocol basics, DBLE's architecture, code structure, execution flow, error handling, transaction logging, recovery mechanisms, and practical considerations for distributed transactions in database middleware.
This article explains how to handle distributed transactions in microservice architectures by using eventual consistency with message middleware, discusses the pitfalls of combining database updates and message sending in a single transaction, and presents a reliable solution involving a message table, background processing, ACK mechanisms, and deduplication.
In this interview, Lu Zhi, the technical lead of Ant Financial's SOFA middleware, discusses the evolution from SOFA4 to SOFA5, the strategic importance of Service Mesh and Serverless, the development of the Seata distributed‑transaction framework, and the team’s open‑source governance and community‑building approaches.
This article, excerpted from the book "Software Architecture Design: Integrating Large‑Scale Website Technical and Business Architecture," systematically presents seven practical solutions—including two eventual‑consistency approaches, two compromise methods, TCC, state‑machine retry with idempotence, and reconciliation—to address the pervasive challenges of distributed transactions in micro‑service systems.
Apache ShardingSphere provides an integrated distributed transaction solution combining traditional ACID‑compliant two‑phase commit, flexible Saga‑based transactions, and automatic transaction management, detailing their architectures, features, trade‑offs, and usage guidelines for developers handling multi‑database microservice environments.
This article examines multiple fault‑tolerant transaction designs—RSM‑based KV, RSM‑based transactions, shared‑storage approaches, high‑availability KV layers, and single‑node engine extensions—comparing their replication strategies, lock handling, and performance trade‑offs while raising open questions about ordering and consistency.
This article explains the distributed‑transaction challenges introduced by microservice architectures, introduces Alibaba’s open‑source Fescar (formerly GTS) as a non‑intrusive, high‑performance solution, and details its design principles, components, AT/MT modes, extension points, and roadmap for future development.
The article explains the Saga pattern as a solution for managing distributed transactions in microservice architectures, comparing event‑driven choreography and command‑oriented orchestration approaches, and discusses their benefits, drawbacks, and rollback strategies.
This article explains how RocketMQ’s transactional message feature enables distributed transaction final consistency by using half messages, message check‑back, and defined transaction states, and provides complete Java code samples for producers, listeners, and consumer idempotency handling.
Fescar, Alibaba’s open‑source Fast & Easy Commit And Rollback (Seata) framework, provides a high‑performance, easy‑to‑use distributed transaction solution for microservice architectures, detailing its components, transaction lifecycle, and evolution from TXC to GTS, and illustrating its role in solving global transaction challenges.
This article introduces Fescar, Alibaba's open‑source distributed transaction framework for microservices, explains the challenges of global transactions, outlines its architecture and components, and reviews its evolution from TXC to GTS to Fescar.
This article explains how to design and implement a reliable message service that ensures atomicity between upstream business transactions and downstream message delivery, using status management, callbacks, and scheduled tasks to achieve eventual consistency in distributed systems.
This article explains the Maximum‑Effort Notification pattern for flexible distributed transactions, detailing its principles, workflow, implementation options, evaluation, and optimization techniques to achieve eventual consistency across services with limited retries and idempotent interfaces.
This article explains the ACID properties of transactions, contrasts them with the CAP theorem and BASE model, and then explores practical distributed‑transaction solutions such as two‑phase commit, TCC, and reliable asynchronous messaging, including their advantages, drawbacks, and implementation tips.
This article chronicles the eight‑month development of ShardingSphere 3.0.0, detailing its origins from Sharding‑JDBC, the addition of Sharding‑Proxy and Sidecar, core feature enhancements, distributed transaction redesign, community growth, and future roadmap for the open‑source database middleware ecosystem.
This article explains the challenges of distributed transactions in microservice architectures, covering database transaction fundamentals, the CAP and BASE theories, and evaluates various solutions such as 2PC, TCC, local message tables, MQ transactional messages, Sagas, and introduces the open‑source .NET CAP framework.
Chubao Database (CBDB) is a second-generation elastic, multi-model database service that supports KV, document, graph, and SQL models via multiple protocols, simplifying stacks, reducing costs, and providing horizontal scalability, high availability, strong consistency, and distributed transactions.
This article explains the fundamentals of distributed transactions, covering ACID and CAP theory, the BASE model, and compares common solutions such as two‑phase commit, TCC, local message tables, MQ transactional messages, and Sagas, while also introducing the open‑source .NET CAP framework with its features and limitations.
This article explains the fundamentals of distributed transactions, why they arise in modern micro‑service architectures, outlines the ACID properties, presents typical use cases such as payments and order processing, and compares common implementation approaches like 2PC, message‑based eventual consistency, and TCC.
This article explains the fundamentals of database transactions, the ACID properties, and how they are implemented, then delves into distributed transaction challenges and solutions such as two‑phase and three‑phase commit, XA, Saga patterns, choreography vs. orchestration, and message‑based transaction mechanisms.
Distributed transactions ensure atomicity across services, and RocketMQ provides a half-message mechanism with a two-phase commit and a rollback check that lets producers and consumers coordinate transaction steps reliably even when confirmations are delayed.
The article explains the necessity of transactions, traces their origins from database XA specifications to modern distributed systems, compares CAP and BASE theories, and reviews mainstream solutions such as two‑phase commit, three‑phase commit, TCC, asynchronous messaging, and the Saga pattern.
This article introduces the TCC (Try‑Confirm‑Cancel) distributed transaction model, explains its two‑phase workflow, and outlines six essential design considerations—including two‑phase operation splitting, empty rollback handling, suspension control, idempotency, data visibility, and concurrency—while sharing Ant Financial’s decade‑long practical experience and solutions.
This article explains why and how relational databases should be sharded, covering vertical and horizontal partitioning techniques, common pitfalls such as distributed transactions and join queries, and practical guidelines for deciding when to split data and which tools to use.
This article reviews Ant Financial's evolution of distributed transaction solutions—from early SOA consistency issues to the high‑performance TCC model, the developer‑friendly FMT approach, and the real‑time XA integration with OceanBase—highlighting architectural decisions, optimizations, and practical outcomes.
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.
The article summarizes four technical sessions from QCon covering Alibaba's Pandora microservice isolation framework and its boot solution, 51 Credit Card's monitoring platform design, JD's Akimed service platform with ContainerMesh and capability mapping, and a saga‑based distributed transaction library, highlighting challenges, implementations, and practical insights.
This article explores the importance of data consistency in distributed systems, illustrating real‑world scenarios, explaining consistency models such as strong, weak and eventual, and detailing the challenges and theories like CAP and BASE that guide system designers in balancing consistency, availability, and partition tolerance.
The article examines the challenges of distributed transactions in microservice architectures, reviews traditional solutions such as XA, TCC, and message-based eventual consistency, and introduces Alibaba’s Global Transaction Service (GTS) as a high‑performance, low‑intrusion middleware with various deployment options and real‑world usage examples.
This article explains the fundamentals of database transactions, the ACID properties, and how they extend to distributed environments, covering two‑phase commit, three‑phase commit, and the TCC model while discussing their advantages, limitations, and practical examples.
This article explains microservice architecture fundamentals, typical design patterns such as chain, aggregator, data‑sharing and asynchronous messaging, and presents practical solutions for service splitting, data consistency, and distributed transaction management based on real‑world experience at the ZhaiZhai platform.
This article clarifies core concepts such as transaction compensation, CAP theorem, idempotency, and BASE, compares rigid ACID‑based transactions with flexible BASE‑based approaches, and provides best‑practice guidance for choosing and implementing 2PC, TCC, and asynchronous assurance patterns in distributed systems.
This article explores the challenges of distributed transactions in microservice architectures, explains consistency theories like CAP and BASE, compares classic 2PC with eBay's event‑queue approach, TCC compensation, and cache‑based eventual consistency, and offers practical guidance for choosing the right solution.
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.
The article explains common interview questions on distributed systems and compares transaction coordination methods, detailing the two‑phase commit drawbacks and introducing three patterns—TCC, asynchronous assurance, and maximum‑effort notification—along with their advantages, usage scenarios, and practical considerations.
This article presents a comprehensive guide to database sharding, covering implementation strategies, vertical and horizontal partitioning, global primary key generation techniques, framework versus custom solutions, multi‑data‑source transaction handling, and a novel, migration‑free scaling approach that combines incremental range and hash‑based routing.
This article explains the core functions of relational‑database middleware, dives into Sharding-JDBC’s architecture, performance characteristics, and implementation details such as sharding rules, SQL parsing, routing, rewrite, execution, result merging, and distributed primary‑key generation, and outlines its future roadmap.
The article explains how to break large transactions into small atomic operations combined with asynchronous messaging, describes ACID properties, presents banking and flow‑recharge scenarios, compares local and distributed (flexible) transactions, and details micro‑service architecture, compensation and async strategies to achieve eventual consistency.
This article explains the principles of distributed transaction design, covering ACID fundamentals, typical banking and e‑commerce scenarios, various transaction models such as two‑phase, compensation, asynchronous and best‑effort notifications, and presents a micro‑service architecture with concrete flow diagrams and scaling strategies for a high‑throughput traffic‑recharge platform.
Ensuring final data consistency in modern applications—whether enterprise or internet—requires understanding ACID, CAP, BASE theories and applying practical techniques such as single-database transactions, two-phase commit, transactional message queues, compensation tasks, async callbacks, and double-check mechanisms to build robust distributed systems.
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.
This article explains practical sharding implementation strategies, global primary‑key generation techniques, framework versus custom solutions, distributed transaction models, and a flexible expansion scheme that avoids data migration while maintaining performance and scalability.
The conversation covers practical challenges and solutions for distributed transactions, evaluates RPC frameworks like Thrift, Dubbo, and gRPC, discusses session replay attack mitigations, and explores reliable messaging patterns using queues and pub/sub systems such as RabbitMQ and Kafka.
The article details how Mogujie's e‑commerce transaction system evolved from a monolithic PHP application to a service‑oriented architecture through DB vertical sharding, service decomposition, custom sharding component TSharding, and performance optimizations such as asynchronous processing, caching, and distributed transaction handling to support rapid growth and high‑availability requirements.
This article explains why transactions are essential, describes the ACID properties, details MySQL's isolation levels and their effects, outlines InnoDB's redo/undo logging mechanism, and introduces distributed transaction models with two‑phase commit, providing practical examples and diagrams.
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.
The article examines the challenges of maintaining data consistency across distributed services in e‑commerce, explains strong, weak and eventual consistency models, and presents six practical solutions—including business integration, the eBay BASE pattern, Qunar, Mogujie, Alipay DTS, and Nongxin—highlighting how local transactions, idempotent messaging, and eventual consistency can replace heavyweight distributed‑transaction frameworks.
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.
This article explains the core concepts of database sharding, detailing vertical and horizontal partitioning methods, strategies for combining them, handling shared data, and addressing challenges such as distributed transactions, cross‑node joins, and aggregation queries, with practical insights for scalable system design.
The article explains the concepts of vertical and horizontal database splitting, compares their technical difficulties, discusses the impact on joins and transactions, and proposes practical approaches such as careful SQL refactoring, ORM decoupling, and selective use of distributed‑transaction techniques to maintain system stability and scalability.
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.
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.
