分布式事务专题3

CrazyClaz2025-12-06 14:21
3.6.2 AT模式

AT(Auto Commit)模式同样是分阶段提交的事务模型，不过缺弥补了XA模型中资源锁定周期过长的缺陷。

1、基本流程图

阶段一RM的工作：

  • 注册分支事务
  • 记录undo-log（数据快照）
  • 执行业务sql并提交，不等待
  • 报告事务状态

阶段二提交时RM的工作：

  • 删除undo-log即可

阶段二回滚时RM的工作：

  • 根据undo-log恢复数据到更新前

2、AT与XA的区别

  • XA模式一阶段不提交事务，锁定资源；AT模式一阶段直接提交，不锁定资源，性能好。
  • XA模式依赖数据库机制实现回滚；AT模式利用数据快照实现数据回滚。
  • XA模式强一致；AT模式最终一致

3、脏写问题

在多线程并发访问AT模式的分布式事务时，有可能出现脏写问题，如图：

阶段1：

  • 事务1先获取DB锁（可以理解为这条数据的行锁），然后保存数据快照，此时记录的数据快照是100
  • 事务1执行业务逻辑，将金额更新为90
  • 事务1提交事务，是否DB锁，此时数据库为90
  • 事务2先获取DB锁（可以理解为这条数据的行锁），然后保存数据快照，此时记录的数据快照是90
  • 事务2执行业务逻辑，将金额更新为80
  • 事务2提交事务，是否DB锁，此时数据库为80

阶段2：

  • 事务1获取DB锁，根据快照回滚数据，直接将数据恢复至100，导致事务2的操作丢失了

解决思路就是引入了全局锁的概念。在释放DB锁之前，先拿到全局锁。避免同一时刻有另外一个事务来操作当前数据。

阶段1：

  • 事务1先获取DB锁（可以理解为这条数据的行锁），然后保存数据快照，此时记录的数据快照是100
  • 事务1执行业务逻辑，将金额更新为90
  • 事务1获取全局锁，提交事务，是否DB锁，此时数据库为90
  • 事务2先获取DB锁（可以理解为这条数据的行锁），然后保存数据快照，此时记录的数据快照是90
  • 事务2执行业务逻辑，将金额更新为80
  • 事务2尝试获取全局锁，因为此时全局锁被事务1持有，事务2阻塞

阶段2：

  • 事务1尝试获取DB锁，因为此时事务2获取到了DB锁，所以事务1也被阻塞了。即事务1持有全局锁，等待DB锁；事务2持有DB锁，等待全局锁，出现了死锁。seata的设计是，持有DB锁的事务2会默认重试30次，每次间隔10毫秒，所以事务2会先超时回滚数据并释放DB锁，接着事务1拿到DB锁去根据快照恢复数据，这样数据就一致了

4、优缺点

AT模式的优点：

  • 一阶段完成直接提交事务，释放数据库资源，性能比较好
  • 利用全局锁实现读写隔离，不像XA模式使用数据库的锁，性能要好一些
  • 没有代码侵入，框架自动完成回滚和提交

AT模式的缺点：

  • 两阶段之间属于软状态，属于最终一致
  • 框架的快照功能会影响性能，但比XA模式要好很多

5、实现AT模式

AT模式中的快照生成、回滚等动作都是由框架自动完成，没有任何代码侵入，因此实现非常简单。

只不过，AT模式需要一个表来记录全局锁、另一张表来记录数据快照undo_log。

1）导入数据库表，记录全局锁

导入课前资料提供的Sql文件：seata-at.sql，其中lock_table导入到TC服务关联的数据库，undo_log表导入到微服务关联的数据库：

sql 复制代码 
/*
 Navicat Premium Data Transfer

 Source Server         : local
 Source Server Type    : MySQL
 Source Server Version : 50622
 Source Host           : localhost:3306
 Source Schema         : seata_demo

 Target Server Type    : MySQL
 Target Server Version : 50622
 File Encoding         : 65001

 Date: 20/06/2021 12:39:03
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for undo_log
-- ----------------------------
DROP TABLE IF EXISTS `undo_log`;
CREATE TABLE `undo_log`  (
  `branch_id` bigint(20) NOT NULL COMMENT 'branch transaction id',
  `xid` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'global transaction id',
  `context` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'undo_log context,such as serialization',
  `rollback_info` longblob NOT NULL COMMENT 'rollback info',
  `log_status` int(11) NOT NULL COMMENT '0:normal status,1:defense status',
  `log_created` datetime(6) NOT NULL COMMENT 'create datetime',
  `log_modified` datetime(6) NOT NULL COMMENT 'modify datetime',
  UNIQUE INDEX `ux_undo_log`(`xid`, `branch_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = 'AT transaction mode undo table' ROW_FORMAT = Compact;

-- ----------------------------
-- Records of undo_log
-- ----------------------------



-- ----------------------------
-- Table structure for lock_table
-- ----------------------------
DROP TABLE IF EXISTS `lock_table`;
CREATE TABLE `lock_table`  (
  `row_key` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `xid` varchar(96) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `transaction_id` bigint(20) NULL DEFAULT NULL,
  `branch_id` bigint(20) NOT NULL,
  `resource_id` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `table_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `pk` varchar(36) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `gmt_create` datetime NULL DEFAULT NULL,
  `gmt_modified` datetime NULL DEFAULT NULL,
  PRIMARY KEY (`row_key`) USING BTREE,
  INDEX `idx_branch_id`(`branch_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;


SET FOREIGN_KEY_CHECKS = 1;

2）修改application.yml文件，将事务模式修改为AT模式即可：

yaml 复制代码 
seata:
  data-source-proxy-mode: AT # 默认就是AT

3）重启服务并测试。可以看到，扣款成功之后执行了回滚。

3.6.3 TCC模式

TCC模式与AT模式非常相似，每阶段都是独立事务，不同的是TCC通过人工编码来实现数据恢复。需要实现三个方法：

  • Try：资源的检测和预留；
  • Confirm：完成资源操作业务；要求 Try 成功 Confirm 一定要能成功。
  • Cancel：预留资源释放，可以理解为try的反向操作。

1、流程分析

举例，一个扣减用户余额的业务。假设账户A原来余额是100，需要余额扣减30元。

  • 阶段一（ Try ）：检查余额是否充足，如果充足则冻结金额增加30元，可用余额扣除30

初识余额：

余额充足，可以冻结：

此时，总金额 = 冻结金额 + 可用金额，数量依然是100不变。事务直接提交无需等待其它事务。

  • 阶段二（Confirm)：假如要提交（Confirm），则冻结金额扣减30

确认可以提交，不过之前可用金额已经扣减过了，这里只要清除冻结金额就好了：

此时，总金额 = 冻结金额 + 可用金额 = 0 + 70 = 70元

  • 阶段二(Canncel)：如果要回滚（Cancel），则冻结金额扣减30，可用余额增加30

需要回滚，那么就要释放冻结金额，恢复可用金额：

AT模式需要加全局锁来保证事务的执行安全，而TCC不需要加全局锁

比如事务1扣款30元，于是冻结金额增加30。事务2也去扣款30元，于是冻结金额增加30，但是两个冻结金额是相互独立的，两个事务操作各自的冻结金额，不会出现线程安全的问题。因此TCC模式不需要锁，性能要比AT模式要好。

2、TCC模型

Seata中的TCC模型依然延续之前的事务架构，如图：

3、优缺点

TCC模式的每个阶段是做什么的？

  • Try：资源检查和预留
  • Confirm：业务执行和提交
  • Cancel：预留资源的释放

TCC的优点是什么？

  • 一阶段完成直接提交事务，释放数据库资源，性能好
  • 相比AT模型，无需生成快照，无需使用全局锁，性能最强
  • 不依赖数据库事务，而是依赖补偿操作，可以用于非事务型数据库

TCC的缺点是什么？

  • 有代码侵入，需要人为编写try、Confirm和Cancel接口，太麻烦
  • 软状态，事务是最终一致
  • 需要考虑Confirm和Cancel的失败情况，失败会重试，所以要做好幂等处理

4、事务悬挂和空回滚

4.1 空回滚

当某分支事务的try阶段阻塞 时，可能导致全局事务超时而触发二阶段的cancel操作。在未执行try操作时先执行了cancel操作，这时cancel不能做回滚，就是空回滚。

解决方案：执行cancel操作时，应当判断try是否已经执行，如果尚未执行，则应该空回滚。

4.2 业务悬挂

对于已经空回滚的业务，之前被阻塞的try操作恢复，继续执行try，就永远不可能confirm或cancel ，事务一直处于中间状态，这就是业务悬挂

解决方案：执行try操作时，应当判断cancel是否已经执行过了，如果已经执行，应当阻止空回滚后的try操作，避免悬挂

5、实现TCC模式

解决空回滚和业务悬挂问题，必须要记录当前事务状态，是在try、还是cancel？

5.1 思路分析

我们必须在数据库记录冻结金额的同时，记录当前事务ID和执行事务状态。这里我们定义一张表：

sql 复制代码 
CREATE TABLE `account_freeze_tbl` (
  `xid` varchar(128) NOT NULL,
  `user_id` varchar(255) DEFAULT NULL COMMENT '用户id',
  `freeze_money` int(11) unsigned DEFAULT '0' COMMENT '冻结金额',
  `state` int(1) DEFAULT NULL COMMENT '事务状态，0:try，1:confirm，2:cancel',
  PRIMARY KEY (`xid`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;

其中：

  • xid：是全局事务id
  • freeze_money：用来记录用户冻结金额
  • state：用来记录事务状态

那此时，我们的业务开怎么做呢？

  • Try业务：
    • 记录冻结金额和事务状态到account_freeze表
    • 扣减account表可用金额
  • Confirm业务
    • 根据xid删除account_freeze表的冻结记录
  • Cancel业务
    • 修改account_freeze表，冻结金额为0，state为2
    • 修改account表，恢复可用金额
  • 如何判断是否空回滚？
    • cancel业务中，根据xid查询account_freeze，如果为null则说明try还没做，需要空回滚
  • 如何避免业务悬挂？
    • try业务中，根据xid查询account_freeze ，如果已经存在则证明Cancel已经执行，拒绝执行try业务

接下来，我们改造account-service，利用TCC实现余额扣减功能。

5.2 声明TCC接口

TCC的Try、Confirm、Cancel方法都需要在接口中基于注解来声明，

我们在account-service项目中的cn.itcast.account.service包中新建一个接口，声明TCC三个接口：

java 复制代码 
package cn.itcast.account.service;

import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;

@LocalTCC
public interface AccountTCCService {

    @TwoPhaseBusinessAction(name = "deduct", commitMethod = "confirm", rollbackMethod = "cancel")
    void deduct(@BusinessActionContextParameter(paramName = "userId") String userId,
                @BusinessActionContextParameter(paramName = "money")int money);

    boolean confirm(BusinessActionContext ctx);

    boolean cancel(BusinessActionContext ctx);
}

解析：

接口要使用@LocalTCC注解标识，@TwoPhaseBusinessAction注解加到哪个方法上面，就代表哪个方法是try。name属性的try的方法名，commitMethod、rollbackMethod分别对应的confirm和cancel方法。

另外，在try方法中有一些业务参数，需要在confirm和cancel方法中用到，所以我们使用@BusinessActionContextParameter注解来声明，然后就可以在confirm和cancel方法中使用BusinessActionContext来获取参数了

5.3 编写实现类

在account-service服务中的cn.itcast.account.service.impl包下新建一个类，实现TCC业务：

java 复制代码 
package cn.itcast.account.service.impl;

import cn.itcast.account.entity.AccountFreeze;
import cn.itcast.account.mapper.AccountFreezeMapper;
import cn.itcast.account.mapper.AccountMapper;
import cn.itcast.account.service.AccountTCCService;
import io.seata.core.context.RootContext;
import io.seata.rm.tcc.api.BusinessActionContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Slf4j
public class AccountTCCServiceImpl implements AccountTCCService {

    @Autowired
    private AccountMapper accountMapper;
    @Autowired
    private AccountFreezeMapper freezeMapper;

    @Override
    @Transactional
    public void deduct(String userId, int money) {
        // 0.获取事务id
        String xid = RootContext.getXID();
        // 1.扣减可用余额
        accountMapper.deduct(userId, money);
        // 2.记录冻结金额，事务状态
        AccountFreeze freeze = new AccountFreeze();
        freeze.setUserId(userId);
        freeze.setFreezeMoney(money);
        freeze.setState(AccountFreeze.State.TRY);
        freeze.setXid(xid);
        freezeMapper.insert(freeze);
    }

    @Override
    public boolean confirm(BusinessActionContext ctx) {
        // 1.获取事务id
        String xid = ctx.getXid();
        // 2.根据id删除冻结记录
        int count = freezeMapper.deleteById(xid);
        return count == 1;
    }

    @Override
    public boolean cancel(BusinessActionContext ctx) {
        // 0.查询冻结记录
        String xid = ctx.getXid();
        AccountFreeze freeze = freezeMapper.selectById(xid);

        // 1.恢复可用余额
        accountMapper.refund(freeze.getUserId(), freeze.getFreezeMoney());
        // 2.将冻结金额清零，状态改为CANCEL
        freeze.setFreezeMoney(0);
        freeze.setState(AccountFreeze.State.CANCEL);
        int count = freezeMapper.updateById(freeze);
        return count == 1;
    }
}

添加空回滚和业务悬挂逻辑，同时考虑幂等

java 复制代码 
package cn.itcast.account.service.impl;

import cn.itcast.account.entity.AccountFreeze;
import cn.itcast.account.mapper.AccountFreezeMapper;
import cn.itcast.account.mapper.AccountMapper;
import cn.itcast.account.service.AccountTCCService;
import io.seata.core.context.RootContext;
import io.seata.rm.tcc.api.BusinessActionContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
@Slf4j
public class AccountTCCServiceImpl implements AccountTCCService {

    @Autowired
    private AccountMapper accountMapper;
    @Autowired
    private AccountFreezeMapper freezeMapper;

    @Override
    @Transactional
    public void deduct(String userId, int money) {
        // 0.获取事务id
        String xid = RootContext.getXID();
        
        // 判断表中是否有记录，如果有，就是CANCEL执行过了，try方法不执行
        AccountFreeze oldFreeze = freezeMapper.selectById(xid);
        if(oldFreeze != null){
            return;
        }
        
        // 1.扣减可用余额
        accountMapper.deduct(userId, money);
        // 2.记录冻结金额，事务状态
        AccountFreeze freeze = new AccountFreeze();
        freeze.setUserId(userId);
        freeze.setFreezeMoney(money);
        freeze.setState(AccountFreeze.State.TRY);
        freeze.setXid(xid);
        freezeMapper.insert(freeze);
    }

    @Override
    public boolean confirm(BusinessActionContext ctx) {
        // 1.获取事务id
        String xid = ctx.getXid();
        // 2.根据id删除冻结记录
        int count = freezeMapper.deleteById(xid);
        return count == 1;
    }

    @Override
    public boolean cancel(BusinessActionContext ctx) {
        // 0.查询冻结记录
        String xid = ctx.getXid();
        String userId = ctx.getActionContext("userId").toString();
        AccountFreeze freeze = freezeMapper.selectById(xid);
        
        // 空回滚判断，如果freeze为null，证明try没有执行，需要空回滚
        if(freeze == null){
            freeze = new AccountFreeze();
        	freeze.setUserId(userId);
        	freeze.setFreezeMoney(0);
        	freeze.setState(AccountFreeze.State.CANCEL);
        	freeze.setXid(xid);
        	freezeMapper.insert(freeze);
            return true;
        }
        
        //幂等判断。因为如果执行过cancel，则数据库里的状态一定是CANCEL，就不需要再次执行了
        if(freeze.getState() == AccountFreeze.State.CANCEL){
            //已经处理过一次cancel，无需重复处理
            return true;
        }

        // 1.恢复可用余额
        accountMapper.refund(freeze.getUserId(), freeze.getFreezeMoney());
        // 2.将冻结金额清零，状态改为CANCEL
        freeze.setFreezeMoney(0);
        freeze.setState(AccountFreeze.State.CANCEL);
        int count = freezeMapper.updateById(freeze);
        return count == 1;
    }
}

注意：cancel方法需要判断空回滚。空回滚不光是return true，还需要在数据库中记录一条cancel记录。

空回滚的时候，要考虑幂等判断。因为如果执行过cancel，则数据库里的状态一定是CANCEL，就不需要再次执行了

为什么confirm没有加幂等判断呢？因为confirm是根据xid删除冻结金额记录，第一次执行删除了，再次执行就没有满足条件的数据了，多次执行是没有影响的

try方法需要加业务悬挂的判断

3.6.4 SAGA模式

Saga 模式是 Seata 即将开源的长事务解决方案，将由蚂蚁金服主要贡献。

其理论基础是Hector & Kenneth 在1987年发表的论文Sagas。

Seata官网对于Saga的指南：https://seata.io/zh-cn/docs/user/saga.html

1、原理

在 Saga 模式下，分布式事务内有多个参与者，每一个参与者都是一个冲正补偿服务，需要用户根据业务场景实现其正向操作和逆向回滚操作。

分布式事务执行过程中，依次执行各参与者的正向操作，如果所有正向操作均执行成功，那么分布式事务提交。如果任何一个正向操作执行失败，那么分布式事务会去退回去执行前面各参与者的逆向回滚操作，回滚已提交的参与者，使分布式事务回到初始状态。

Saga也分为两个阶段：

  • 一阶段：直接提交本地事务
  • 二阶段：成功则什么都不做；失败则通过编写补偿业务来回滚

2、优缺点

优点：

  • 事务参与者可以基于事件驱动实现异步调用，吞吐高
  • 一阶段直接提交事务，无锁，性能好
  • 不用编写TCC中的三个阶段，实现简单

缺点：

  • 软状态持续时间不确定，时效性差
  • 没有锁，没有事务隔离，会有脏写
3.6.5 四种模式对比

我们从以下几个方面来对比四种实现：

  • 一致性：能否保证事务的一致性？强一致还是最终一致？
  • 隔离性：事务之间的隔离性如何？
  • 代码侵入：是否需要对业务代码改造？
  • 性能：有无性能损耗？
  • 场景：常见的业务场景

如图：

相关推荐
梁萌4 小时前
分布式事物seata的AT模式实战
分布式·微服务·实战·seata·一致性·事物
shaohaoyongchuang4 小时前
01-分布式基础-创建微服务项目
分布式·微服务·架构
失伟5 小时前
kafka教程（新手使用单机版）
分布式·kafka
Xyz996_6 小时前
Ceph分布式存储
分布式·ceph
绝顶少年6 小时前
Redis 五大核心应用场景实战解析：缓存、会话、排行榜、分布式锁与消息队列
redis·分布式·缓存
武子康6 小时前
Java-181 OSS 实战指南：Bucket/外链/防盗链/计费与常见坑
java·大数据·分布式·oss·云存储·fastdfs·ali
沧海寄馀生6 小时前
Apache Hadoop生态组件部署分享-Impala
大数据·hadoop·分布式·apache
写bug的小屁孩6 小时前
5.Kafka-HW重要特性与场景分析
分布式·中间件·kafka
嘉禾望岗5037 小时前
spark计算框架与RDD特性介绍
大数据·分布式·spark
热门推荐
01GitHub 镜像站点02React CVE-2025-55182漏洞排查与修复指南03【超详细教程】手把手教你从微软官网免费下载Windows 10官方原版ISO镜像（2025最新版）04安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）05UV安装并设置国内源06BongoCat - 跨平台键盘猫动画工具07智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践08本地部署阿里最新开源的Z-Image09Linux下V2Ray安装配置指南10论文阅读 - 深度学习端到端解决库存管理问题 - 有限时间范围内的多周期补货问题（Management Science）