分布式事务

最新推荐文章于 2024-07-25 23:20:03 发布

endorphinnnn

最新推荐文章于 2024-07-25 23:20:03 发布

阅读量187

点赞数

分类专栏：笔记文章标签：分布式面试 java

本文链接：https://blog.csdn.net/DOVISSSS/article/details/126885859

版权

笔记专栏收录该内容

42 篇文章 1 订阅

订阅专栏

面试题

什么是本地事务？什么是分布式事务？
什么是CAP定理？为什么必须保证P？为什么在保证P的前提下只能保证C或者A其中一个？
什么是BASE理论？
seata解决分布式事务的三个角色以及分别的作用什么？
seata解决分布式事务的四种模式
XA模式特点、原理以及应用场景？优缺点有哪些？
AT模式特点、原理以及应用场景？优缺点有哪些？有可能会出现什么问题？如何解决？
重点：TCC模式特点、原理以及应用场景？优缺点有哪些？有可能会出现什么问题？什么是空回滚和业务悬挂，如何解决？
SAGA模式特点、原理以及应用场景？优缺点有哪些？

1、分布式事务问题

1.1.本地事务

也就是传统的单机事务，在传统数据库事务中，必须满足四个原则：

原子性
一致性
隔离性
持久性

1.2.分布式事务

就是指不是在单个服务或单个数据库架构下，产生的事务。在数据库水平拆分、服务垂直拆分之后，一个业务操作通常要跨多个数据库、服务才能完成。我们把多个事务看成“一个业务”，要满足保证“业务”的原子性，要么全部成功要么全部失败。

但此时ACID较难满足，这则是分布式事务要解决的问题。

2、理论基础

2.1.CAP定理

分布式系统有三个指标：

Consistency（一致性）
Availability（可用性）
Partition tolerance（分区容错）

一致性

用户访问分布式系统中的任意节点，得到的数据必须一致。

可用性

用户访问集群中的任意健康节点，必须能得到响应，而不是超时或拒绝。

分区容错

分区：因为网络故障或其他原因导致分布式系统中的部分节点与其他节点失去连接，形成独立分区。
容错：在集群出现分区时，整个系统也要持续对外提供服务。

矛盾

分布式系统说，网络不能保证完全健康，但服务必须对外保证服务，因此分区容错不可避免。
当节点出现新的数据变更时，如果要保证一致性，就必须等待网络恢复，完成数据同步后再对外提供服务。此时服务处于阻塞状态，不可用。
此时如果要保证可用性，就不能等待网络恢复，但此时节点之间会出现不一致状态。
综上，在P一定会出现的情况下，AC只能实现一个。

2.2.BASE理论

BASE理论是对CAP的一种解决思路，包含三个思想：

Basically Available（基本可用）：分布式系统在出现故障的时候，允许损失部分可用性，保证核心可用
Soft state（软状态）：在一定时间内，允许出现中间状态，比如临时的不一致状态
Eventually Consistency（最终一致性）：虽然无法保证强一致性，但是在软状态结束后，最终达到数据一致。

2.3.解决分布式事务的思路

借鉴CAP定理和BASE理论，有两种解决思路：

AP模式：
- 各子事务分别执行和提交，允许出现结果不一致，然后采用弥补措施恢复数据即可，实现最终一致。
CP模式：
- 各个子事务执行后互相等待，同时提交，同时回滚，达成强一致。但事务等待过程中，处于弱可用状态。

不管是哪一种模式，都需要在子系统事务之间互相通讯，协调事务状态，也就是需要一个事务协调者（TC）。
请添加图片描述

这里的子系统事务，成为分支事务，有关联的各个分支事务在一起成为全局事务。

3、初始Seata

3.1.Seata架构

Seata事务管理中有三个重要的角色：

TC：事务协调者
- 维护全局和分支事务的状态，协调全局事务提交或回滚
TM：事务管理器
- 定义全局事务的范围、开始全局事务、提交或回滚全局事务
RM：资源管理器
- 管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚

Seata基于上述架构提供了四种不同的分布式事务解决方案：

XA模式
- 强一致性分阶段事务模式，牺牲了一定的可用性，无业务侵入
TCC模式
- 最终一致的分阶段事务模式，有业务侵入
AT模式
- 最终一致的分阶段事务模式，无业务侵入，也是Seata的默认模式
SAGA模式
- 长事务模式，有业务侵入

3.3.微服务集成TC

引入依赖

<!--seata-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
    <exclusions>
        <!--版本较低，1.3.0，因此排除--> 
        <exclusion>
            <artifactId>seata-spring-boot-starter</artifactId>
            <groupId>io.seata</groupId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <!--seata starter 采用1.4.2版本-->
    <version>${seata.version}</version>
</dependency>

配置 TC地址

seata:
  registry: # TC服务注册中心的配置，微服务根据这些信息去注册中心获取tc服务地址
    type: nacos # 注册中心类型 nacos
    nacos:
      server-addr: 127.0.0.1:8848 # nacos地址
      namespace: "" # namespace，默认为空
      group: DEFAULT_GROUP # 分组，默认是DEFAULT_GROUP
      application: seata-tc-server # seata服务名称
      username: nacos
      password: nacos
  tx-service-group: seata-demo # 事务组名称
  service:
    vgroup-mapping: # 事务组与cluster的映射关系
      seata-demo: SH   # cluster

微服务如何根据配置寻找TC地址？
我们知道注册到Nacos中的微服务，确定一个具体实例需要四个信息：

namespace：命名空间，如果为空就是默认的public
group：分组
application：服务名
cluster：集群名

结合起来，TC服务的信息就是：public@DEFAULT_GROUP@seata-tc-server@SH，这样就能确定TC服务集群了。然后就可以去Nacos拉取对应的实例信息了。

4、Seata中的四种不同的事务模式

4.1.XA模式

XA 规范是 X/Open 组织定义的分布式事务处理（DTP，Distributed Transaction Processing）标准，XA规范描述了全局的TM与局部的RM之间的接口，几乎所有主流的数据库都对XA规范提供了支持。

两阶段提交

正常情况：
请添加图片描述
异常情况：

一阶段：

TM通知每个事务参与者执行本地事务
本地事务执行完成后报告事务执行状态给事务协调者，此时事务不提交，继续持有数据库锁

二阶段：

TM基于一阶段的报告来判断下一步操作
如果一阶段都成功，则通知所有事务参与者，提交事务
如果一阶段任意一个参与者失败，则通知所有事务参与者回滚事务

XA模型

Seata对原始的XA模式做了简单的封装和改造，以适应自己的事务模型，基本架构图如图所示：
请添加图片描述
RM一阶段的工作：

① 注册分支事务到TC

② 执行分支业务sql但不提交

③ 报告执行状态到TC

TC二阶段的工作：

TC检测各分支事务执行状态
a.如果都成功，通知所有RM提交事务
b.如果有失败，通知所有RM回滚事务

RM二阶段的工作：

接收TC指令，提交或回滚事务

优缺点

优点
- 事务的强一致性，满足ACID原则
- 常用数据库都支持，实现简单，并且没有代码侵入
缺点
- 因为一阶段需要锁定数据库资源，等待二阶段结束才释放，性能较差
- 依赖关系型数据库实现事务

实现XA模式

修改application.yaml文件（每个参与事务的微服务），开启XA模式

seata:
  data-source-proxy-mode: XA

给发起全局事务的入口方法添加@GlobalTransactional注解

4.2.AT模式

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

AT模型
请添加图片描述
阶段一RM的工作：

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

阶段二提交时RM的工作：

删除undo-log即可

阶段二回滚时RM的工作：

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

AT与XA的区别

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

脏写问题

在多线程并发访问AT模式的分布式事务时，第二个线程事务提交完毕，释放DB锁，然后第一个线程出现差错，需要根据快照恢复数据，此时快照中的数据是第一个线程第一次获取DB锁后生成的。
第二个线程在之后运行，修改了数据，此时第一个线程需要恢复的数据是第二个线程运行后的数据而非自己最初保存的快照，故有可能出现脏写问题。
解决思路就是引入了全局锁的概念，在释放DB锁之前，先闹到全局锁，避免同一时刻有另外一个事务来操作当前数据。

优缺点

优点
- 一阶段完成直接提交事务，释放数据库资源，性能比较好
- 利用全局锁实现读写隔离
- 没有代码侵入，框架自动完成回滚和提交
缺点
- 两阶段之间属于软状态，属于最终一致
- 框架的快照功能会影响性能，但比XA模式要好很多

实现AT模式

AT模式中的快照生成、回滚等动作都是由框架自动完成，没有任何代码侵入，因此实现非常简单。
只不过，AT模式需要一个表来记录全局锁、另一张表来记录数据快照undo_log。
修改application.yml文件

seata:
  data-source-proxy-mode: AT # 默认就是AT

4.3.TCC模式

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

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

TCC模型

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

请添加图片描述

优缺点

优点
- 一阶段完成直接提交事务，释放数据库资源，性能好
- 相比AT模型，无需生成快照，无需使用全局锁，性能最强
- 不依赖数据库事务，而是依赖补偿操作，可以用于非事务型数据库
缺点
- 有代码侵入，需要人为编写try、Confirm和Cancel接口，太麻烦
- 软状态，事务是最终一致
- 需要考虑Confirm和Cancel的失败情况，做好幂等处理

事务悬挂和空回滚

当某分支事务的try阶段阻塞时，可能导致全局事务超时而触发二阶段的cancel操作。在未执行try操作时先执行了cancel操作，这时cancel不能做回滚，就是空回滚。执行cancel操作时，应当判断try是否已经执行，如果尚未执行，则应该空回滚。
对于已经空回滚的业务，之前被阻塞的try操作恢复，继续执行try，就永远不可能confirm或cancel ，事务一直处于中间状态，这就是业务悬挂。执行try操作时，应当判断cancel是否已经执行过了，如果已经执行，应当阻止空回滚后的try操作，避免悬挂

实现TCC模式

定义一张表

# xid：是全局事务id
# freeze_money：用来记录用户冻结金额
# state：用来记录事务状态
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;

业务实现思路

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业务

声明TCC接口

@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);
}

编写实现类

@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;
    }
}