分布式事务

ADCQprogrammer

已于 2022-07-26 00:00:48 修改

阅读量196

点赞数

分类专栏：事务 distribute 文章标签：分布式数据库 java

于 2022-07-21 01:17:15 首次发布

本文链接：https://blog.youkuaiyun.com/ADCQprogrammer/article/details/125903831

版权

distribute 同时被 2 个专栏收录

5 篇文章

订阅专栏

事务

3 篇文章

订阅专栏

分布式事务

1、简介：

1.1、定义：

非单个服务或单个数据库架构下，产生的事务

1.2、分类：

跨数据源的分布式事务(DB多)
跨服务的分布式事务
综合情况

跨数据源

数据库多台

随着业务数据规模的快速发展，数据量越来越大，单库单表逐渐成为瓶颈。
我们对数据库进行了水平拆分，将原单库单表拆分成数据库分片，于是就产生了跨数据库事务问题。
每个库内部都有自己的事务(ACID)
需要分布式事务

跨服务

在业务发展初期，单体系统架构，能满足基本的业务需求。但是随着业务的快速发展，系统的访问量和业务复杂程度都在快速增长，单系统架构逐渐成为业务发展瓶颈，解决业务系统的高耦合、可伸缩问题的需求越来越强烈。
如下图所示，按照面向服务（SOA）的架构的设计原则，将单业务系统拆分成多个业务系统，降低了各系统之间的耦合度，使不同的业务系统专注于自身业务，更有利于业务的发展和系统容量的伸缩。
每个微服务模块都有自己的tm(spring),每个都不一样
多系统多个事务期望值;一个失败，全部失败
分布式事务

分布式系统的数据一致性问题

在数据库水平拆分、服务垂直拆分之后，一个业务操作通常要跨多个数据库、服务才能完成。
在分布式网络环境下，我们无法保障所有服务、数据库都百分百可用，会出现部分服务、数据库执行成功，另一部分执行失败的问题。
当出现部分业务操作成功、部分业务操作失败时，业务数据就会出现不一致。
例如电商行业中比较常见的下单付款案例，包括下面几个行为：
- 创建新订单
- 扣减商品库存
- 从用户账户余额扣除金额
完成上面的操作需要访问三个不同的微服务和三个不同的数据库。
在分布式环境下，肯定会出现部分操作成功、部分操作失败的问题，比如：订单生成了，库存也扣减了，但是用户账户的余额不足，这就造成数据不一致。
订单的创建、库存的扣减、账户扣款在每一个服务和数据库内是一个本地事务，可以保证ACID原则。
当我们把三件事情看做一个事情事，要满足保证“业务”的原子性，要么所有操作全部成功，要么全部失败，不允许出现部分成功部分失败的现象，这就是分布式系统下的事务了。
此时ACID难以满足，这是分布式事务要解决的问题

2、分阶段提交

2.1、DTP和XA

分布式事务的解决手段之一，就是两阶段提交协议（2PC：Two-Phase Commit）
DTP：Distributed Transaction Procesing Reference Model
DTP XA规范（全称为Dstrluted Tanacto Poesng∶The XA Specification）
X/Open，即现在的open group，是一个全球联盟的独立的组织
两阶段提交协议:

1994 年，X/Open 组织（即现在的 Open Group ）定义了分布式事务处理的DTP 模型。该模型包括这样几个角色：
- 应用程序（ AP ）：我们的微服务
- 事务管理器（ TM ）：全局事务管理者
- 资源管理器（ RM ）：一般是数据库
- 通信资源管理器（ CRM ）：是TM和RM间的通信中间件
在该模型中，一个分布式事务（全局事务）可以被拆分成许多个本地事务，运行在不同的AP和RM上。每个本地事务的ACID很好实现，但是全局事务必须保证其中包含的每一个本地事务都能同时成功，若有一个本地事务失败，则所有其它事务都必须回滚。
问题是，本地事务处理过程中，并不知道其它事务的运行状态。因此，就需要通过CRM来通知各个本地事务，同步事务执行的状态。
因此，各个本地事务的通信必须有统一的标准，否则不同数据库间就无法通信。
XA就是 X/Open DTP中通信中间件与TM间联系的接口规范，定义了用于通知事务开始、提交、终止、回滚等接口，各个数据库厂商都必须实现这些接口。

2.2、二阶段提交

参考：漫话分布式系统共识协议: 2PC/3PC篇

二阶提交协议就是根据这一思想衍生出来的，将全局事务拆分为两个阶段来执行：

阶段一：准备阶段，各个本地事务完成本地事务的准备工作。
阶段二：执行阶段，各个本地事务根据上一阶段执行结果，进行提交或回滚。
这个过程中需要一个协调者（coordinator），还有事务的参与者（voter）。

1）正常情况

在这里插入图片描述

投票阶段：协调组询问各个事务参与者，是否可以执行事务。每个事务参与者执行事务，写入redo和undo日志，然后反馈事务执行成功的信息（agree）
提交阶段：协调组发现每个参与者都可以执行事务（agree），于是向各个事务参与者发出commit指令，各个事务参与者提交事务。

2）异常情况

在这里插入图片描述

投票阶段：协调组询问各个事务参与者，是否可以执行事务。每个事务参与者执行事务，写入redo和undo日志，然后反馈事务执行结果，但只要有一个参与者返回的是Disagree，则说明执行失败。

提交阶段：协调组发现有一个或多个参与者返回的是Disagree，认为执行失败。于是向各个事务参与者发出abort指令，各个事务参与者回滚事务。

3）缺陷

二阶段提交的问题：

单点故障问题
- 2PC的缺点在于不能处理fail-stop形式的节点故障. 比如下图这种情况.:
  
  假设coordinator和voter3都在Commit这个阶段crash了, 而voter1和voter2没有收到commit消息. 这时候voter1和voter2就陷入了一个困境. 因为他们并不能判断现在是两个场景中的哪一种:
  (1)上轮全票通过然后voter3第一个收到了commit的消息并在commit操作之后crash了
  (2)上轮voter3反对所以干脆没有通过.
阻塞问题
- 在准备阶段、提交阶段，每个事物参与者都会锁定本地资源，并等待其它事务的执行结果，阻塞时间较长，资源锁定时间太久，因此执行的效率就比较低了。
- 可能发生死锁。

面对二阶段提交的上述缺点，后来又演变出了三阶段提交，但是依然没有完全解决阻塞和资源锁定的问题，而且引入了一些新的问题，因此实际使用的场景较少。
对事务有强一致性要求，对事务执行效率不敏感，并且不希望有太多代码侵入。

2.3.TCC

TCC模式可以解决2PC中的资源锁定和阻塞问题，减少资源锁定时间。

2.3.1.基本原理

本质是一种补偿的思路。事务运行过程包括三个方法，==

Try：资源的检测和预留；
Confirm：执行的业务操作提交；要求 Try 成功 Confirm 一定要能成功
Cancel：预留资源释放。

执行分两个阶段

准备阶段（try）：资源的检测和预留；
执行阶段（confirm/cancel）：根据上一步结果，判断下面的执行方法。如果上一步中所有事务参与者都成功，则这里执行confirm。反之，执行cancel
-
try、confirm、cancel都是独立的事务，不受其它参与者的影响，不会阻塞等待它人
try、confirm、cancel由程序员在业务层编写，锁粒度有代码控制

2.3.2.实例

我们以之前的下单业务中的扣减余额为例来看下三个不同的方法要怎么编写，假设账户A原来余额是100，需要余额扣减30元。如图：
在这里插入图片描述

一阶段（Try）：余额检查，并冻结用户部分金额，此阶段执行完毕，事务已经提交
- 检查用户余额是否充足，如果充足，冻结部分余额
- 在账户表中添加冻结金额字段，值为30，余额不变
二阶段
- 提交（Confirm）：真正的扣款，把冻结金额从余额中扣除，冻结金额清空
  - 修改冻结金额为0，修改余额为100-30 = 70元
- 补偿（Cancel）：释放之前冻结的金额，并非回滚
  - 余额不变，修改账户冻结金额为0

2.3.3.优势和缺点

优势：
- TCC执行的每一个阶段都会提交本地事务并释放锁，并不需要等待其它事务的执行结果。而如果其它事务执行失败，最后不是回滚，而是执行补偿操作。这样就避免了资源的长期锁定和阻塞等待，执行效率比较高，属于性能比较好的分布式事务方式。
缺点:
- 代码侵入：需要人为编写代码实现try、confirm、cancel，代码侵入较多
- 开发成本高：一个业务需要拆分成3个步骤，分别编写业务实现，业务编写比较复杂
- 安全性考虑：cancel动作如果执行失败，资源就无法释放，需要引入重试机制，而重试可能导致重复执行，还要考虑重试时的幂等问题

2.3.4.使用场景

对事务有一定的一致性要求（最终一致）
对性能要求较高
开发人员具备较高的编码能力和幂等处理经验

2.4 可靠消息服务

依靠MQ的可靠性实现
源于ebay，基本的设计思想是将远程分布式事务拆分成一系列的本地事务。
消息重试

2.4.1、基本原理

一般分为事务的发起者和事务的其他参与者B

事务发起者A执行本地事务
事务A通过MQ将需要执行的事务信息发给事务参与者B
事务参与者B接收到消息后执行本地事务

这个过程类似于去学校食堂吃饭：
- 拿着钱去收银处，点一份红烧牛肉面，付钱
- 收银处给你发一个小票(消息)，还有一个号牌，你别把票弄丢！
- 你凭小票和号牌一定能领到一份红烧牛肉面，不管需要多久
几个注意事项：
- 事务发起者A必须确保本地事务成功后，消息一定发送成功
- MQ必须保证消息正确投递和持久化保存
- 事务参与者B必须确保消息最终一定能消费，如果失败需要多次重试
- 事务B执行失败，会重试，但不会导致事务A回滚
  问题：如何保证消息发送一定成功？如何保证消费者一定能收到消息？

2.4.2.本地消息表

为了避免消息发送失败或丢失，我们可以把消息持久化到数据库中。实现时有简化版本和解耦合版本两种方式。

1）简化版本

原理图： 在这里插入图片描述

事务发起者：
- 开启本地事务
- 执行事务相关业务
- 发送消息到MQ
- 把消息持久化到数据库，标记为已发送
- 提交本地事务
事务接收者：
- 接收消息
- 开启本地事务
- 处理事务相关业务
- 修改数据库消息状态为已消费
- 提交本地事务
额外的定时任务
- 定时扫描表中超时未消费消息，重新发送

缺点：

数据一致性完全依赖于消息服务，因此消息服务必须是可靠的。
需要处理被动业务方的幂等问题
被动业务失败不会导致主动业务的回滚，而是重试被动的业务
事务业务与消息发送业务耦合、业务数据与消息表要在一起。

2）独立消息服务

为了解决上述问题，我们会引入一个独立的消息服务，来完成对消息的持久化、发送、确认、失败重试等一系列行为，大致的模型如下：
一次发送消息

事务发起者A的基本执行步骤：

开启本地事务
通知消息服务，准备发送消息（消息服务将消息持久化，标记为准备发送）
执行本地业务，
- 执行失败则终止，通知消息服务，取消发送（消息服务修改订单状态）
- 执行成功则继续，通知消息服务，确认发送（消息服务发送消息、修改订单状态）
提交本地事务

消息服务本身提供下面的接口：

准备发送：把消息持久化到数据库，并标记状态为准备发送
取消发送：把数据库消息状态修改为取消
确认发送：把数据库消息状态修改为确认发送。尝试发送消息，成功后修改状态为已发送
确认消费：消费者已经接收并处理消息，把数据库消息状态修改为已消费
定时任务：定时扫描数据库中状态为确认发送的消息，然后询问对应的事务发起者，事务业务执行是否成功，结果：
- 业务执行成功：尝试发送消息，成功后修改状态为已发送
- 业务执行失败：把数据库消息状态修改为取消

事务参与者B的基本步骤：

接收消息
开启本地事务
执行业务
通知消息服务，消息已经接收和处理
提交事务

优点：

解除了事务业务与消息相关业务的耦合

缺点：

实现起来比较复杂

2.4.3.RocketMQ事务消息

RocketMQ本身自带了事务消息，可以保证消息的可靠性，
原理其实就是自带了本地消息表，与我们上面讲的思路类似。

2.4.4.RabbitMQ的消息确认

RabbitMQ确保消息不丢失的思路比较奇特，并没有使用传统的本地表，而是利用了消息的确认机制：

生产者确认机制：确保消息从生产者到达MQ不会有问题
- 消息生产者发送消息到RabbitMQ时，可以设置一个异步的监听器，监听来自MQ的ACK
- MQ接收到消息后，会返回一个回执给生产者：
  - 消息到达交换机后路由失败，会返回失败ACK
  - 消息路由成功，持久化失败，会返回失败ACK
  - 消息路由成功，持久化成功，会返回成功ACK
- 生产者提前编写好不同回执的处理方式
  - 失败回执：等待一定时间后重新发送
  - 成功回执：记录日志等行为
消费者确认机制：确保消息能够被消费者正确消费
- 消费者需要在监听队列的时候指定手动ACK模式
- RabbitMQ把消息投递给消费者后，会等待消费者ACK，接收到ACK后才删除消息，如果没有接收到ACK消息会一直保留在服务端，如果消费者断开连接或异常后，消息会投递给其它消费者。
- 消费者处理完消息，提交事务后，手动ACK。如果执行过程中抛出异常，则不会ACK，业务处理失败，等待下一条消息

经过上面的两种确认机制，可以确保从消息生产者到消费者的消息安全，再结合生产者和消费者两端的本地事务，即可保证一个分布式事务的最终一致性。

2.4.5.消息事务的优缺点

总结上面的几种模型，消息事务的优缺点如下：

优点：
- 业务相对简单，不需要编写三个阶段业务
- 是多个本地事务的结合，因此资源锁定周期短，性能好
缺点：
- 代码侵入
- 依赖于MQ的可靠性
- 消息发起者可以回滚，但是消息参与者无法引起事务回滚
- 事务时效性差，取决于MQ消息发送是否及时，还有消息参与者的执行情况

针对事务无法回滚的问题，有人提出说可以再事务参与者执行失败后，再次利用MQ通知消息服务，然后由消息服务通知其他参与者回滚。那么，MQ和自定义的消息服务再次实现了2PC 模型，又造了一个大轮子。

2.5、AT模式

2019年 1 月份，Seata 开源了 AT 模式。AT 模式是一种无侵入的分布式事务解决方案。可以看做是对TCC或者二阶段提交模型的一种优化，解决了TCC模式中的代码侵入、编码复杂等问题。(springcloud)
在 AT 模式下，用户只需关注自己的“业务 SQL”，用户的 “业务 SQL” 作为一阶段，Seata 框架会自动生成事务的二阶段提交和回滚操作。
可以参考Seata的官方文档。

2.5.1.基本原理

先来看一张流程图：
在这里插入图片描述
跟TCC的执行很像，都是分两个阶段：

一阶段：执行本地事务，并返回执行结果
二阶段：根据一阶段的结果，判断二阶段做法：提交或回滚

但AT模式底层做的事情可完全不同，第二阶段根本不需要我们编写，全部有Seata自己实现了。也就是说：我们写的代码与本地事务时代码一样，无需手动处理分布式事务。
那么，AT模式如何实现无代码侵入，如何帮我们自动实现二阶段代码的呢？

一阶段

在一阶段，Seata 会拦截“业务 SQL”，首先解析 SQL 语义，找到“业务 SQL”要更新的业务数据，在业务数据被更新前，将其保存成“before image”，
然后执行“业务 SQL”更新业务数据，在业务数据更新之后，再将其保存成“after image”，
最后获取全局行锁，提交事务。
以上操作全部在一个数据库事务内完成，这样保证了一阶段操作的原子性。
这里的before image和after image类似于数据库的undo和redo日志，但其实是用数据库模拟的。

二阶段提交

二阶段如果是提交的话，因为“业务 SQL”在一阶段已经提交至数据库，所以 Seata 框架只需将一阶段保存的快照数据和行锁删掉，完成数据清理即可。

二阶段回滚：

二阶段如果是回滚的话，Seata 就需要回滚一阶段已经执行的“业务 SQL”，还原业务数据。
回滚方式便是用“before image”还原业务数据；但在还原前要首先要校验脏写，对比“数据库当前业务数据”和 “after image”，如果两份数据完全一致就说明没有脏写，可以还原业务数据，如果不一致就说明有脏写，出现脏写就需要转人工处理。
不过因为有全局锁机制，所以可以降低出现脏写的概率。
AT 模式的一阶段、二阶段提交和回滚均由 Seata 框架自动生成，用户只需编写“业务 SQL”，便能轻松接入分布式事务，
AT 模式是一种对业务无任何侵入的分布式事务解决方案。

2.5.2.详细架构和流程

Seata中的几个基本概念：

TC（Transaction Coordinator） - 事务协调者，维护全局和分支事务的状态，驱动全局事务提交或回滚（TM之间的协调者）。
TM（Transaction Manager）事务管理器，定义全局事务的范围：开始全局事务、提交或回滚全局事务。
RM（Resource Manager）资源管理器，管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚。
架构图如下：
TM：业务模块中全局事务的开启者
- 向TC开启一个全局事务
- 调用其它微服务
RM：业务模块执行者中，包含RM部分，负责向TC汇报事务执行状态
- 执行本地事务
- 向TC注册分支事务，并提交本地事务执行结果
TM：结束对微服务的调用，通知TC，全局事务执行完毕，事务一阶段结束
TC：汇总各个分支事务执行结果，决定分布式事务是提交还是回滚；
TC 通知所有 RM 提交/回滚资源，事务二阶段结束。

一阶段：

TM开启全局事务，并向TC声明全局事务，包括全局事务XID信息
TM所在服务调用其它微服务
微服务，主要有RM来执行
- 查询before_image
- 执行本地事务
- 查询after_image
- 生成undo_log并写入数据库
- 向TC注册分支事务，告知事务执行结果
- 获取全局锁（阻止其它全局事务并发修改当前数据）
- 释放本地锁（不影响其它业务对数据的操作）
待所有业务执行完毕，事务发起者（TM）会尝试向TC提交全局事务

二阶段：

TC统计分支事务执行情况，根据结果判断下一步行为
- 分支都成功：通知分支事务，提交事务
- 有分支执行失败：通知执行成功的分支事务，回滚数据
分支事务的RM
- 提交事务：直接清空before_image和after_image信息，释放全局锁
- 回滚事务：
  - 校验after_image，判断是否有脏写
  - 如果没有脏写，回滚数据到before_image，清除before_image和after_image
  - 如果有脏写，请求人工介入

2.5.3.工作机制

详见Seata的官方文档：https://seata.io/zh-cn/docs/overview/what-is-seata.html

场景

一个示例来说明整个 AT 分支的工作过程。
业务表：product

Field	Type	Key
id	bigint(20)	PRI主键
name	varchar(100)
since	varchar(100)

AT 分支事务的业务逻辑：

update product set name = 'GTS' where name = 'TXC';

一阶段

过程：

解析 SQL：得到 SQL 的类型（UPDATE），表（product），条件（where name = ‘TXC’）等相关的信息。
查询前镜像：根据解析得到的条件信息，生成查询语句，定位数据。
```
select id, name, since from product where name = 'TXC';
```

得到前镜像：

id	name	since
1	TXC	2014

执行业务 SQL：更新这条记录的 name 为 ‘GTS’。
查询后镜像：根据前镜像的结果，通过主键定位数据。
```
select id, name, since from product where id = 1`;
```

得到后镜像：

id	name	since
1	GTS	2014

插入回滚日志：把前后镜像数据以及业务 SQL 相关的信息组成一条回滚日志记录，插入到 UNDO_LOG 表中。

{
	"branchId": 641789253,
	"undoItems": [{
		"afterImage": {
			"rows": [{
				"fields": [{
					"name": "id",
					"type": 4,
					"value": 1
				}, {
					"name": "name",
					"type": 12,
					"value": "GTS"
				}, {
					"name": "since",
					"type": 12,
					"value": "2014"
				}]
			}],
			"tableName": "product"
		},
		"beforeImage": {
			"rows": [{
				"fields": [{
					"name": "id",
					"type": 4,
					"value": 1
				}, {
					"name": "name",
					"type": 12,
					"value": "TXC"
				}, {
					"name": "since",
					"type": 12,
					"value": "2014"
				}]
			}],
			"tableName": "product"
		},
		"sqlType": "UPDATE"
	}],
	"xid": "xid:xxx"
}

提交前，向 TC 注册分支：申请 product 表中，主键值等于 1 的记录的 全局锁 。
本地事务提交：业务数据的更新和前面步骤中生成的 UNDO LOG 一并提交。
将本地事务提交的结果上报给 TC。

二阶段-回滚

收到 TC 的分支回滚请求，开启一个本地事务，执行如下操作。
通过 XID 和 Branch ID 查找到相应的 UNDO LOG 记录。
数据校验：拿 UNDO LOG 中的后镜与当前数据进行比较，如果有不同，说明数据被当前全局事务之外的动作做了修改。这种情况，需要根据配置策略来做处理，详细的说明在另外的文档中介绍。
根据 UNDO LOG 中的前镜像和业务 SQL 的相关信息生成并执行回滚的语句：
```
update product set name = 'TXC' where id = 1;
```
提交本地事务。并把本地事务的执行结果（即分支事务回滚的结果）上报给 TC。

二阶段-提交

收到 TC 的分支提交请求，把请求放入一个异步任务的队列中，马上返回提交成功的结果给 TC。
异步任务阶段的分支提交请求将异步和批量地删除相应 UNDO LOG 记录。

2.5.4.优缺点

优点：

与2PC相比：每个分支事务都是独立提交，不互相等待，减少了资源锁定和阻塞时间
与TCC相比：二阶段的执行操作全部自动化生成，无代码侵入，开发成本低
缺点：
与TCC相比，需要动态生成二阶段的反向补偿操作，执行性能略低于TCC

2.6、Saga模式

Saga 模式是 Seata 即将开源的长事务解决方案，将由蚂蚁金服主要贡献。
其理论基础是Hector & Kenneth 在1987年发表的论文Sagas。
Seata官网对于Saga的指南：https://seata.io/zh-cn/docs/user/saga.html

2.6.1、基本模型

在 Saga 模式下，分布式事务内有多个参与者，每一个参与者都是一个冲正补偿服务，需要用户根据业务场景实现其正向操作和逆向回滚操作。
分布式事务执行过程中，依次执行各参与者的正向操作，如果所有正向操作均执行成功，那么分布式事务提交。如果任何一个正向操作执行失败，那么分布式事务会去退回去执行前面各参与者的逆向回滚操作，回滚已提交的参与者，使分布式事务回到初始状态。

Saga 模式下分布式事务通常是由事件驱动的，各个参与者之间是异步执行的，Saga 模式是一种长事务解决方案。