罕用的分布式事务解决方案

家喻户晓，数据库能实现本地事务，也就是在同一个数据库中，你能够容许一组操作要么全都正确执行，要么全都不执行。这里特别强调了本地事务，也就是目前的数据库只能反对同一个数据库中的事务。但当初的零碎往往采纳微服务架构，业务零碎领有独立的数据库，因而就呈现了跨多个数据库的事务需要，这种事务即为“分布式事务”。那么在目前数据库不反对跨库事务的状况下，咱们应该如何实现分布式事务呢？本文首先会为大家梳理分布式事务的基本概念和实践根底，而后介绍几种目前罕用的分布式事务解决方案。废话不多说，那就开始吧～

1. 什么是事务？

事务由一组操作形成，咱们心愿这组操作可能全副正确执行，如果这一组操作中的任意一个步骤产生谬误，那么就须要回滚之前曾经实现的操作。也就是同一个事务中的所有操作，要么全都正确执行，要么全都不要执行。

2. 事务的四大个性 ACID

说到事务，就不得不提一下事务驰名的四大个性。

• 原子性(Atomicity) 原子性要求，事务是一个不可分割的执行单元，事务中的所有操作要么全都执行，要么全都不执行。
• 一致性(Consistency) 一致性要求，事务在开始前和完结后，数据库的完整性束缚没有被毁坏。
• 隔离性(Isolation) 事务的执行是互相独立的，它们不会互相烦扰，一个事务不会看到另一个正在运行过程中的事务的数据。
• 持久性(Durability) 持久性要求，一个事务实现之后，事务的执行后果必须是长久化保留的。即便数据库产生解体，在数据库复原后事务提交的后果依然不会失落。

留神：事务只能保障数据库的 高可靠性 ，即数据库自身产生问题后，事务提交后的数据依然能复原；而如果不是数据库自身的故障，如硬盘损坏了，那么事务提交的数据可能就失落了。这属于『 高可用性』的领域。因而，事务只能保障数据库的『高可靠性』，而『高可用性』须要整个零碎独特配合实现。

3. 事务的隔离级别

这里扩大一下，对事务的 隔离性 做一个具体的解释。

在事务的四大个性 ACID 中，要求的隔离性是一种严格意义上的隔离，也就是多个事务是串行执行的，彼此之间不会受到任何烦扰。这的确可能齐全保证数据的安全性，但在理论业务零碎中，这种形式性能不高。因而，数据库定义了四种隔离级别，** 隔离级别和数据库的性能是呈正比的，隔离级别越低，数据库性能越高，而隔离级别越高，数据库性能越差 **。

3.1 事务并发执行会呈现的问题

咱们先来看一下在不同的隔离级别下，数据库可能会呈现的问题：

1. 更新失落 当有两个并发执行的事务，更新同一行数据，那么有可能一个事务会把另一个事务的更新笼罩掉。当数据库没有加任何锁操作的状况下会产生。
2. 脏读 一个事务读到另一个尚未提交的事务中的数据。该数据可能会被回滚从而生效。如果第一个事务拿着生效的数据去解决那就产生谬误了。

3. 不可反复读 不可反复度的含意：一个事务对同一行数据读了两次，却失去了不同的后果。它具体分为如下两种状况：

   • 虚读：在事务 1 两次读取同一记录的过程中，事务 2 对该记录进行了批改，从而事务 1 第二次读到了不一样的记录。
   • 幻读：事务 1 在两次查问的过程中，事务 2 对该表进行了插入、删除操作，从而事务 1 第二次查问的后果产生了变动。

不可反复读 与 脏读 的区别？脏读读到的是尚未提交的数据，而不可反复读读到的是曾经提交的数据，只不过在两次读的过程中数据被另一个事务改过了。

3.2 数据库的四种隔离级别

数据库一共有如下四种隔离级别：

1. Read uncommitted 读未提交 在该级别下，一个事务对一行数据批改的过程中，不容许另一个事务对该行数据进行批改，但容许另一个事务对该行数据读。因而本级别下，不会呈现更新失落，但 会呈现脏读、不可反复读。
2. Read committed 读提交 在该级别下，未提交的写事务不容许其余事务拜访该行， 因而不会呈现脏读 ；然而读取数据的事务容许其余事务的拜访该行数据，因而会呈现 不可反复读 的状况。

3. Repeatable read 可反复读 在该级别下，读事务禁止写事务，但容许读事务，因而不会呈现同一事务两次读到不同的数据的状况（不可反复读），且写事务禁止其余所有事务。

   mysql 查看以后事物级别:SELECT @@tx_isolation;
   REPEATABLE-READ

4. Serializable 序列化 该级别要求所有事务都必须串行执行，因而能防止所有因并发引起的问题，但效率很低。在该隔离级别下事务都是串行程序执行的，MySQL 数据库的 InnoDB 引擎会给读操作隐式加一把读 共享锁，从而防止了脏读、不可重读复读和幻读问题。

    select * from tableName where... lock in share mode;

共享锁（也称为 S 锁）：容许事务读取一行数据。

能够应用 SQL 语句 select * from tableName where... lock in share mode; 手动加 S 锁。

独占锁（也称为 X 锁）：容许事务删除或更新一行数据。

能够应用 SQL 语句 select * from tableName where... for update; 手动加 X 锁。

S 锁和 S 锁是 兼容 的，X 锁和其它锁都 不兼容 ，举个例子，事务 T1 获取了一个行 r1 的 S 锁，另外事务 T2 能够立刻取得行 r1 的 S 锁，此时 T1 和 T2 独特取得行 r1 的 S 锁，此种状况称为 锁兼容 ，然而另外一个事务 T2 此时如果想取得行 r1 的 X 锁，则必须期待 T1 对行 r 锁的开释，此种状况也成为 锁抵触。

隔离级别越高，越能保证数据的完整性和一致性，然而对并发性能的影响也越大。对于少数应用程序，能够优先思考把数据库系统的隔离级别设为Read Committed。它可能防止脏读取，而且具备较好的并发性能。只管它会导致不可反复读、幻读和第二类失落更新这些并发问题，在可能呈现这类问题的个别场合，能够由应用程序采纳乐观锁或乐观锁来管制。

4. 什么是分布式事务？

到此为止，所介绍的事务都是基于单数据库的本地事务，目前的数据库仅反对单库事务，并不反对跨库事务。而随着微服务架构的遍及，一个大型业务零碎往往由若干个子系统形成，这些子系统又领有各自独立的数据库。往往一个业务流程须要由多个子系统共同完成，而且这些操作可能须要在一个事务中实现。在微服务零碎中，这些业务场景是普遍存在的。此时，咱们就须要在数据库之上通过某种伎俩，实现反对跨数据库的事务反对，这也就是大家常说的“分布式事务”。

这里举一个分布式事务的典型例子——用户下单过程。当咱们的零碎采纳了微服务架构后，一个电商零碎往往被拆分成如下几个子系统：商品零碎、订单零碎、领取零碎、积分零碎等。整个下单的过程如下：

1. 用户通过商品零碎浏览商品，他看中了某一项商品，便点击下单
2. 此时订单零碎会生成一条订单
3. 订单创立胜利后，领取零碎提供领取性能
4. 当领取实现后，由积分零碎为该用户减少积分

上述步骤 2、3、4 须要在一个事务中实现。对于传统单体利用而言，实现事务非常简单，只需将这三个步骤放在一个办法 A 中，再用 Spring 的 @Transactional 注解标识该办法即可。Spring 通过数据库的事务反对，保障这些步骤要么全都执行实现，要么全都不执行。但在这个微服务架构中，这三个步骤波及三个零碎，波及三个数据库，此时咱们必须在数据库和利用零碎之间，通过某项黑科技，实现分布式事务的反对。

5. CAP 实践

CAP 实践说的是：在一个分布式系统中，最多只能满足 C、A、P 中的两个需要(AP/CP)。

CAP 的含意：

• C：Consistency 一致性：同一数据的多个正本是否实时雷同。
• A：Availability 可用性：肯定工夫内 & 零碎返回一个明确的后果 则称为该零碎可用。
• P：Partition tolerance 分区容错性：将同一服务散布在多个零碎中，从而保障某一个零碎宕机，依然有其余零碎提供雷同的服务。

CAP 实践通知咱们，在分布式系统中，C、A、P 三个条件中咱们最多只能抉择两个。那么问题来了，到底抉择哪两个条件较为适合呢？

对于一个业务零碎来说，可用性和分区容错性是必须要满足的两个条件，并且这两者是相辅相成的。业务零碎之所以应用分布式系统，次要起因有两个：

• 晋升整体性能 当业务量猛增，单个服务器曾经无奈满足咱们的业务需要的时候，就须要应用分布式系统，应用多个节点提供雷同的性能，从而整体上晋升零碎的性能，这就是应用分布式系统的第一个起因。
• 实现分区容错性 繁多节点 或 多个节点处于雷同的网络环境下，那么会存在肯定的危险，万一该机房断电、该地区产生自然灾害，那么业务零碎就全面瘫痪了。为了避免这一问题，采纳分布式系统，将多个子系统散布在不同的地区、不同的机房中，从而保证系统高可用性。

这阐明分区容错性是分布式系统的基本，如果分区容错性不能满足，那应用分布式系统将失去意义。

此外，可用性对业务零碎也尤为重要。在大谈用户体验的明天，如果业务零碎时常呈现“零碎异样”、响应工夫过长等状况，这使得用户对系统的好感度大打折扣，在互联网行业竞争强烈的明天，雷同畛域的竞争者不甚枚举，零碎的间歇性不可用会立马导致用户流向竞争对手 。因而，咱们只能通过就义一致性来换取零碎的 可用性 和分区容错性。这也就是上面要介绍的 BASE 实践。

6. BASE 实践

CAP 实践通知咱们一个悲惨但不得不承受的事实——咱们只能在 C、A、P 中抉择两个条件。而对于业务零碎而言，咱们往往抉择就义一致性来换取零碎的可用性和分区容错性。不过这里要指出的是，所谓的“就义一致性”并不是齐全放弃数据一致性，而是就义 强一致性 换取 弱一致性。上面来介绍下 BASE 实践。

• BA：Basic Available 根本可用。

  • 整个零碎在某些不可抗力的状况下，依然可能保障“可用性”，即肯定工夫内依然可能返回一个明确的后果。只不过“根本可用”和“高可用”的区别是：

    • “肯定工夫”能够适当缩短 当举办大促时，响应工夫能够适当缩短
    • 给局部用户返回一个降级页面 给局部用户间接返回一个降级页面，从而缓解服务器压力。但要留神，返回降级页面依然是返回明确后果。
• S：Soft State：柔性状态 同一数据的不同正本的状态，能够不须要实时统一。
• E：Eventual Consisstency：最终一致性 同一数据的不同正本的状态，能够不须要实时统一，但肯定要保障通过肯定工夫后依然是统一的。

7. 酸碱均衡

ACID 可能保障事务的强一致性，即数据是实时统一的。这在本地事务中是没有问题的，在分布式事务中，强一致性会极大影响分布式系统的性能，因而分布式系统中遵循 BASE 实践即可。但分布式系统的不同业务场景对一致性的要求也不同。如交易场景下，就要求强一致性，此时就须要遵循 ACID 实践，而在注册胜利后发送短信验证码等场景下，并不需要实时统一，因而遵循 BASE 实践即可。因而要依据具体业务场景，在 ACID 和 BASE 之间寻求均衡。

8. 分布式事务协定

上面介绍几种实现分布式事务的协定。

8.1 两阶段提交协定 2PC

分布式系统的一个难点是 如何保障架构下多个节点在进行事务性操作的时候放弃一致性。为实现这个目标，二阶段提交算法的成立基于以下假如：

• 该分布式系统中，存在一个节点作为 协调者 (Coordinator)，其余节点作为 参与者(Cohorts)。且节点之间能够进行网络通信。
• 所有节点都采纳 预写式日志，且日志被写入后即被放弃在牢靠的存储设备上，即便节点损坏不会导致日志数据的隐没。
• 所有节点不会永久性损坏，即便损坏后依然能够复原。

1. 第一阶段（投票阶段）：

1.  协调者节点向所有参与者节点 ** 询问 ** 是否能够执行提交操作(vote)，并开始期待各参与者节点的响应。2.  参与者节点执行询问发动为止的所有事务操作，并将 **Undo 信息 ** 和 **Redo 信息 ** 写入日志。（留神：若胜利这里其实每个参与者曾经执行了事务操作）3.  各参与者节点响应协调者节点发动的询问。如果参与者节点的事务操作理论执行胜利，则它返回一个 "批准" 音讯；如果参与者节点的事务操作理论执行失败，则它返回一个 "停止" 音讯。

Undo 日志记录某数据被批改前的值，能够用来在事务失败时进行 rollback；Redo 日志记录某数据块被批改后的值，能够用来复原未写入 data file 的已胜利事务更新的数据。

2. 第二阶段（提交执行阶段）：

当协调者节点从所有参与者节点取得的相应音讯都为 ” 批准 ” 时：

1.  协调者节点向所有参与者节点收回 "** 正式提交(commit)**" 的申请。2.  参与者节点正式实现操作，并开释在整个事务期间内占用的资源。3.  参与者节点向协调者节点发送 "实现" 音讯。4.  协调者节点受到所有参与者节点反馈的 "实现" 音讯后，实现事务。

如果任一参与者节点在第一阶段返回的响应音讯为 ” 停止 ”，或者协调者节点在第一阶段的询问超时之前无奈获取所有参与者节点的响应音讯时：

1.  协调者节点向所有参与者节点收回 "** 回滚操作(rollback)**" 的申请。2.  参与者节点利用之前写入的 **Undo 信息 ** 执行回滚，并开释在整个事务期间内占用的资源。3.  参与者节点向协调者节点发送 "回滚实现" 音讯。4.  协调者节点受到所有参与者节点反馈的 "回滚实现" 音讯后，勾销事务。

不论最初后果如何，第二阶段都会完结以后事务。

二阶段提交看起来的确可能提供原子性的操作 ，然而可怜的事， 二阶段提交还是有几个毛病的：

1.  执行过程中，所有参加节点都是 ** 事务阻塞型 ** 的。当参与者占有公共资源时，其余第三方节点拜访公共资源不得不处于阻塞状态。2.  参与者产生故障。协调者须要给每个参与者额定指定 ** 超时机制 **，超时后整个事务失败。（没有多少容错机制）3.  协调者产生故障。参与者会始终阻塞上来。须要额定的备机进行容错。（这个能够依赖前面要讲的 Paxos 协定实现 HA）4.  二阶段无奈解决的问题：协调者再收回 commit 音讯之后宕机，而惟一接管到这条音讯的参与者同时也宕机了。那么即便协调者通过选举协定产生了新的协调者，这条事务的状态也是不确定的，没人晓得事务是否被曾经提交。

为此，Dale Skeen 和 Michael Stonebraker 在“A Formal Model of Crash Recovery in a Distributed System”中提出了三阶段提交协定（3PC）。

8.2 三阶段提交协定 3PC

与两阶段提交不同的是，三阶段提交有两个改变点。

• 引入 超时机制。同时在协调者和参与者中都引入超时机制。
• 在第一阶段和第二阶段中插入一个 筹备阶段。保障了在最初提交阶段之前各参加节点的状态是统一的。

也就是说，除了引入超时机制之外，3PC 把 2PC 的筹备阶段再次一分为二，这样三阶段提交就有 CanCommit、PreCommit、DoCommit 三个阶段。

1. CanCommit 阶段

3PC 的 CanCommit 阶段其实和 2PC 的筹备阶段很像。协调者向参与者发送 commit 申请，参与者如果能够提交就返回 Yes 响应，否则返回 No 响应。

1.  事务询问 协调者向参与者发送 CanCommit 申请。询问是否能够执行事务提交操作。而后开始期待参与者的响应。2.  响应反馈 参与者接到 CanCommit 申请之后，失常状况下，如果其本身认为能够顺利执行事务，则返回 Yes 响应，并进入准备状态。否则反馈 No

2. PreCommit 阶段

协调者依据参与者的反馈状况来决定是否能够忘性事务的 PreCommit 操作。依据响应状况，有以下两种可能。如果协调者从所有的参与者取得的反馈都是 Yes 响应，那么就会执行事务的预执行。

1.  发送预提交申请 协调者向参与者发送 PreCommit 申请，并进入 `Prepared 阶段 `。2.  事务预提交 参与者接管到 PreCommit 申请后，会执行事务操作，并将 undo 和 redo 信息记录到事务日志中。3.  响应反馈 如果参与者胜利的执行了事务操作，则返回 `ACK 响应 `，同时开始期待最终指令。

如果有任何一个参与者向协调者发送了 No 响应，或者期待超时之后，协调者都没有接到参与者的响应，那么就执行事务的中断。

1.  发送中断请求 协调者向所有参与者发送 abort 申请。2.  中断事务 参与者收到来自协调者的 abort 申请之后（或超时之后，仍未收到协调者的申请），执行事务的中断。

3. doCommit 阶段 该阶段进行真正的事务提交，也能够分为以下两种状况。

该阶段进行真正的事务提交，也能够分为以下两种状况。

3.1 执行提交

1.  发送提交申请 协调接管到参与者发送的 ACK 响应，那么他将从预提交状态进入到提交状态。并向所有参与者发送 `doCommit 申请 `。2.  事务提交 参与者接管到 doCommit 申请之后，执行正式的事务提交。并在实现事务提交之后开释所有事务资源。3.  响应反馈 事务提交完之后，向协调者发送 Ack 响应。4.  实现事务 协调者接管到所有参与者的 ack 响应之后，实现事务。

3.2 中断事务 协调者没有接管到参与者发送的 ACK 响应（可能是接受者发送的不是 ACK 响应，也可能响应超时），那么就会执行中断事务。

1.  发送中断请求 协调者向所有参与者发送 abort 申请

2.  事务回滚 参与者接管到 abort 申请之后，利用其在阶段二记录的 undo 信息来执行事务的回滚操作，并在实现回滚之后开释所有的事务资源。3.  反馈后果 参与者实现事务回滚之后，向协调者发送 ACK 音讯

4.  中断事务 协调者接管到参与者反馈的 ACK 音讯之后，执行事务的中断。

9. 分布式事务的解决方案

分布式事务的解决方案有如下几种：

• 全局事务
• 基于可靠消息服务的分布式事务
• TCC
• 最大致力告诉

9.1 计划 1：全局事务（DTP 模型）

全局事务基于 DTP 模型实现。DTP 是由 X /Open 组织提出的一种分布式事务模型——X/Open Distributed Transaction Processing Reference Model。它规定了要实现分布式事务，须要三种角色：

• AP：Application 利用零碎 它就是咱们开发的业务零碎，在咱们开发的过程中，能够应用资源管理器提供的事务接口来实现分布式事务。

• TM：Transaction Manager 事务管理器

  • 分布式事务的实现由事务管理器来实现，它会提供分布式事务的操作接口供咱们的业务零碎调用。这些接口称为 TX 接口。

  • 事务管理器还治理着所有的资源管理器，通过它们提供的 XA 接口来同一调度这些资源管理器，以实现分布式事务。

  • DTP 只是一套实现分布式事务的标准，并没有定义具体如何实现分布式事务，TM 能够采纳 2PC、3PC、Paxos 等协定实现分布式事务。

• RM：Resource Manager 资源管理器

  • 可能提供数据服务的对象都能够是资源管理器，比方：数据库、消息中间件、缓存等。大部分场景下，数据库即为分布式事务中的资源管理器。

  • 资源管理器可能提供单数据库的事务能力，它们通过 XA 接口，将本数据库的提交、回滚等能力提供给事务管理器调用，以帮忙事务管理器实现分布式的事务管理。

  • XA 是 DTP 模型定义的接口，用于向事务管理器提供该资源管理器 (该数据库) 的提交、回滚等能力。

  • DTP 只是一套实现分布式事务的标准，RM 具体的实现是由数据库厂商来实现的。

  9.2 计划 2：基于可靠消息服务的分布式事务

  这种实现分布式事务的形式须要通过消息中间件来实现。假如有 A 和 B 两个零碎，别离能够解决工作 A 和工作 B。此时零碎 A 中存在一个业务流程，须要将工作 A 和工作 B 在同一个事务中解决。上面来介绍基于消息中间件来实现这种分布式事务。

• 在零碎 A 解决工作 A 前，首先向消息中间件发送一条音讯。
• 消息中间件收到后将该条音讯长久化，但并不投递。此时上游零碎 B 依然不晓得该条音讯的存在。
• 消息中间件长久化胜利后，便向零碎 A 返回一个确认应答。
• 零碎 A 收到确认应答后，则能够开始解决工作 A。
• 工作 A 解决实现后，向消息中间件发送 Commit 申请。该申请发送实现后，对系统 A 而言，该事务的处理过程就完结了，此时它能够解决别的工作了。 但 commit 音讯可能会在传输途中失落，从而消息中间件并不会向零碎 B 投递这条音讯，从而零碎就会呈现不一致性。这个问题由消息中间件的事务回查机制实现，下文会介绍。
• 消息中间件收到 Commit 指令后，便向零碎 B 投递该音讯，从而触发工作 B 的执行；
• 当工作 B 执行实现后，零碎 B 向消息中间件返回一个确认应答，通知消息中间件该音讯曾经胜利生产，此时，这个分布式事务实现。

上述过程能够得出如下几个论断：

1. 消息中间件扮演者分布式事务协调者的角色。
2. 零碎 A 实现工作 A 后，到工作 B 执行实现之间，会存在肯定的时间差。在这个时间差内，整个零碎处于数据不统一的状态，但这短暂的不一致性是能够承受的，因为通过短暂的工夫后，零碎又能够保持数据一致性，满足 BASE 实践。

上述过程中，如果工作 A 解决失败，那么须要进入回滚流程，如下图所示：

• 若零碎 A 在解决工作 A 时失败，那么就会向消息中间件发送 Rollback 申请。和发送 Commit 申请一样，零碎 A 发完之后便能够认为回滚曾经实现，它便能够去做其余的事件。
• 消息中间件收到回滚申请后，间接将该音讯抛弃，而不投递给零碎 B，从而不会触发零碎 B 的工作 B。

此时零碎又处于一致性状态，因为工作 A 和工作 B 都没有执行。

下面所介绍的 Commit 和 Rollback 都属于现实状况，但在理论零碎中，Commit 和 Rollback 指令都有可能在传输途中失落。

那么当呈现这种状况的时候，消息中间件是如何保证数据一致性呢？

——答案就是 超时询问机制。

零碎 A 除了实现失常的业务流程外，还需提供一个事务询问的接口，供消息中间件调用。当消息中间件收到一条事务型音讯后便开始计时，如果到了超时工夫也没收到零碎 A 发来的 Commit 或 Rollback 指令的话，就会被动调用零碎 A 提供的事务询问接口询问该零碎目前的状态。该接口会返回三种后果：

• 提交 若取得的状态是“提交”，则将该音讯投递给零碎 B。
• 回滚 若取得的状态是“回滚”，则间接将条音讯抛弃。
• 解决中 若取得的状态是“解决中”，则持续期待。

消息中间件的超时询问机制可能避免上游零碎因在传输过程中失落 Commit/Rollback 指令而导致的零碎不统一状况，而且能升高上游零碎的阻塞工夫，上游零碎只有收回 Commit/Rollback 指令后便能够解决其余工作，无需期待确认应答。而 Commit/Rollback 指令失落的状况通过超时询问机制来补救，这样大大降低上游零碎的阻塞工夫，晋升零碎的并发度。

上面来说一说音讯投递过程的可靠性保障。

当上游零碎执行完工作并向消息中间件提交了 Commit 指令后，便能够解决其余工作了，此时它能够认为事务曾经实现，接下来消息中间件 ** 肯定会保障音讯被上游零碎胜利生产掉！
那么这是怎么做到的呢？这由消息中间件的投递流程来保障。

消息中间件向上游零碎投递完音讯后便进入阻塞期待状态，上游零碎便立刻进行工作的解决，工作解决实现后便向消息中间件返回应答。消息中间件收到确认应答后便认为该事务处理完毕！

如果音讯在投递过程中失落，或音讯的确认应答在返回途中失落，那么消息中间件在期待确认应答超时之后就会从新投递，直到上游消费者返回生产胜利响应为止。当然，个别消息中间件能够设置音讯重试的次数和工夫距离，比方：当第一次投递失败后，每隔五分钟重试一次，一共重试 3 次。如果重试 3 次之后依然投递失败，那么这条音讯就须要 人工干预。

有的同学可能要问：音讯投递失败后为什么不回滚音讯，而是一直尝试从新投递？

这就波及到整套分布式事务零碎的实现老本问题。咱们晓得，当零碎 A 将向消息中间件发送 Commit 指令后，它便去做别的事件了。如果此时音讯投递失败，须要回滚的话，就须要让零碎 A 当时提供回滚接口，这无疑减少了额定的开发成本，业务零碎的复杂度也将进步。对于一个业务零碎的设计指标是，在保障性能的前提下，最大限度地升高零碎复杂度，从而可能升高零碎的运维老本。

不知大家是否发现，上游零碎 A 向消息中间件提交 Commit/Rollback 音讯采纳的是异步形式，也就是当上游零碎提交完音讯后便能够去做别的事件，接下来提交、回滚就齐全交给消息中间件来实现，并且齐全信赖消息中间件，认为它肯定能正确地实现事务的提交或回滚。然而，消息中间件向上游零碎投递音讯的过程是同步的。也就是消息中间件将音讯投递给上游零碎后，它会阻塞期待，等上游零碎胜利解决完工作返回确认应答后才勾销阻塞期待。为什么这两者在设计上是不统一的呢？

首先，上游零碎和消息中间件之间采纳异步通信是为了进步零碎并发度。业务零碎间接和用户打交道，用户体验尤为重要，因而这种异步通信形式可能极大水平地升高用户等待时间。此外，异步通信绝对于同步通信而言，没有了长时间的阻塞期待，因而零碎的并发性也大大增加。但异步通信可能会引起 Commit/Rollback 指令失落的问题，这就由消息中间件的超时询问机制来补救。

那么，消息中间件和上游零碎之间为什么要采纳同步通信呢？

异步能晋升零碎性能，但随之会减少零碎复杂度；而同步尽管升高零碎并发度，但实现老本较低。因而，在对并发度要求不是很高的状况下，或者服务器资源较为富余的状况下，咱们能够抉择同步来升高零碎的复杂度。咱们晓得，消息中间件是一个独立于业务零碎的第三方中间件，它不和任何业务零碎产生间接的耦合，它也不和用户产生间接的关联，它个别部署在独立的服务器集群上，具备良好的可扩展性，所以不用太过于放心它的性能，如果处理速度无奈满足咱们的要求，能够减少机器来解决。而且，即便消息中间件处理速度有肯定的提早那也是能够承受的，因为后面所介绍的 BASE 实践就通知咱们了，咱们谋求的是最终一致性，而非实时一致性，因而消息中间件产生的时延导致事务短暂的不统一是能够承受的。

9.3 计划 3：最大致力告诉（定期校对）

最大致力告诉也被称为定期校对，其实在计划二中曾经蕴含，这里再独自介绍，次要是为了常识体系的完整性。这种计划也须要消息中间件的参加，其过程如下：

• 上游零碎在实现工作后，向消息中间件同步地发送一条音讯，确保消息中间件胜利长久化这条音讯，而后上游零碎能够去做别的事件了；
• 消息中间件收到音讯后负责将该音讯同步投递给相应的上游零碎，并触发上游零碎的工作执行；
• 当上游零碎解决胜利后，向消息中间件反馈确认应答，消息中间件便能够将该条音讯删除，从而该事务实现。

下面是一个理想化的过程，但在理论场景中，往往会呈现如下几种意外状况：

1. 消息中间件向上游零碎投递音讯失败。
2. 上游零碎向消息中间件发送音讯失败。

对于第一种状况，消息中间件具备重试机制，咱们能够在消息中间件中设置音讯的重试次数和重试工夫距离，对于网络不稳固导致的音讯投递失败的状况，往往重试几次后音讯便能够胜利投递，如果超过了重试的下限依然投递失败，那么消息中间件不再投递该音讯，而是记录在失败音讯表中，消息中间件须要提供失败音讯的查问接口，上游零碎会定期查问失败音讯，并将其生产，这就是所谓的“定期校对”。

如果反复投递和定期校对都不能解决问题，往往是因为上游零碎呈现了重大的谬误，此时就须要 人工干预。

对于第二种状况，须要在上游零碎中建设音讯重发机制。能够在上游零碎建设一张本地音讯表，并将 工作处理过程 和 向本地音讯表中插入音讯 这两个步骤放在一个本地事务中实现。如果向本地音讯表插入音讯失败，那么就会触发回滚，之前的工作处理结果就会被勾销。如果这量步都执行胜利，那么该本地事务就实现了。接下来会有一个专门的音讯发送者一直地发送本地音讯表中的音讯，如果发送失败它会返回重试。当然，也要给音讯发送者设置重试的下限，一般而言，达到重试下限依然发送失败，那就意味着消息中间件呈现重大的问题，此时也只有人工干预能力解决问题。

对于不反对事务型音讯的消息中间件，如果要实现分布式事务的话，就能够采纳这种形式 。它可能通过 重试机制 + 定期校对 实现分布式事务，但相比于第二种计划，它达到数据一致性的周期较长，而且还须要在上游零碎中实现音讯重试公布机制，以确保音讯胜利公布给消息中间件，这无疑减少了业务零碎的开发成本，使得业务零碎不够纯正，并且这些额定的业务逻辑无疑会占用业务零碎的硬件资源，从而影响性能。

因而，尽量抉择反对事务型音讯的消息中间件来实现分布式事务，如 RocketMQ。

9.4 计划 4：TCC（两阶段型、弥补型）

TCC 即为 Try Confirm Cancel，它属于弥补型分布式事务。顾名思义，TCC 实现分布式事务一共有三个步骤：

• Try：尝试待执行的业务

  • 这个过程并未执行业务，只是实现所有业务的一致性查看，并预留好执行所需的全副资源

• Confirm：执行业务

  • 这个过程真正开始执行业务，因为 Try 阶段曾经实现了一致性查看，因而本过程间接执行，而不做任何查看。并且在执行的过程中，会应用到 Try 阶段预留的业务资源。

• Cancel：勾销执行的业务

  • 若业务执行失败，则进入 Cancel 阶段，它会开释所有占用的业务资源，并回滚 Confirm 阶段执行的操作。

上面以一个转账的例子来解释下 TCC 实现分布式事务的过程。

假如用户 A 用他的账户余额给用户 B 发一个 100 元的红包，并且余额零碎和红包零碎是两个独立的零碎。

• Try

  • 创立一条转账流水，并将流水的状态设为 交易中
  • 将用户 A 的账户中扣除 100 元（预留业务资源）
  • Try 胜利之后，便进入 Confirm 阶段
  • Try 过程产生任何异样，均进入 Cancel 阶段

• Confirm

  • 向 B 用户的红包账户中减少 100 元
  • 将流水的状态设为 交易已实现
  • Confirm 过程产生任何异样，均进入 Cancel 阶段
  • Confirm 过程执行胜利，则该事务完结

• Cancel

  • 将用户 A 的账户减少 100 元
  • 将流水的状态设为 交易失败

在传统事务机制中，业务逻辑的执行和事务的解决，是在不同的阶段由不同的部件来实现的：业务逻辑局部拜访资源实现数据存储，其解决是由业务零碎负责；事务处理局部通过协调资源管理器以实现事务管理，其解决由事务管理器来负责。二者没有太多交互的中央，所以，传统事务管理器的事务处理逻辑，仅须要着眼于事务实现（commit/rollback）阶段，而不用关注业务执行阶段。

这种计划说实话简直很少人应用，然而也有应用的场景。因为这个 事务回滚实际上是重大依赖于你本人写代码来回滚和弥补 了，会造成弥补代码微小，十分之恶心。

9.4.1 TCC 全局事务必须基于 RM 本地事务来实现全局事务

TCC 服务是由 Try/Confirm/Cancel 业务形成的，其 Try/Confirm/Cancel 业务在执行时，会拜访资源管理器（Resource Manager，下文简称 RM）来存取数据。这些存取操作，必须要参加 RM 本地事务，以使其更改的数据要么都 commit，要么都 rollback。

这一点不难理解，考虑一下如下场景：

假如图中的服务 B 没有基于 RM 本地事务（以 RDBS 为例，可通过设置 auto-commit 为 true 来模仿），那么一旦 [B:Try] 操作中途执行失败，TCC 事务框架后续决定回滚全局事务时，该 [B:Cancel] 则须要判断 [B:Try] 中哪些操作曾经写到 DB、哪些操作还没有写到 DB：假如 [B:Try] 业务有 5 个写库操作，[B:Cancel]业务则须要一一判断这 5 个操作是否失效，并将失效的操作执行反向操作。

可怜的是，因为 [B:Cancel] 业务也有 n（0<=n<=5）个反向的写库操作，此时一旦 [B:Cancel] 也中途出错，则后续的 [B:Cancel] 执行工作更加沉重。因为，相比第一次 [B:Cancel] 操作，后续的 [B:Cancel] 操作还须要判断先前的 [B:Cancel] 操作的 n（0<=n<=5）个写库中哪几个曾经执行、哪几个还没有执行，这就波及到了幂等性问题。而对幂等性的保障，又很可能还须要波及额定的写库操作，该写库操作又会因为没有 RM 本地事务的反对而存在相似问题。。。可想而知，如果不基于 RM 本地事务，TCC 事务框架是无奈无效的治理 TCC 全局事务的。

反之，基于 RM 本地事务的 TCC 事务，这种状况则会很容易解决：[B:Try]操作中途执行失败，TCC 事务框架将其参加 RM 本地事务间接 rollback 即可。后续 TCC 事务框架决定回滚全局事务时，在晓得“[B:Try]操作波及的 RM 本地事务曾经 rollback”的状况下，基本无需执行 [B:Cancel] 操作。

换句话说，基于 RM 本地事务实现 TCC 事务框架时，一个 TCC 型服务的 cancel 业务要么执行，要么不执行，不须要思考局部执行的状况。

9.4.2 TCC 事务框架应该提供 Confirm/Cancel 服务的幂等性保障

个别认为，服务的幂等性，是指针对同一个服务的屡次 (n>1) 申请和对它的单次 (n=1) 申请，二者具备雷同的副作用。

在 TCC 事务模型中，Confirm/Cancel 业务可能会被反复调用，其起因很多。比方，全局事务在提交 / 回滚时会调用各 TCC 服务的 Confirm/Cancel 业务逻辑。执行这些 Confirm/Cancel 业务时，可能会呈现如网络中断的故障而使得全局事务不能实现。因而，故障复原机制后续依然会从新提交 / 回滚这些未实现的全局事务，这样就会再次调用参加该全局事务的各 TCC 服务的 Confirm/Cancel 业务逻辑。

既然 Confirm/Cancel 业务可能会被屡次调用，就须要保障其幂等性。那么，应该由 TCC 事务框架来提供幂等性保障？还是应该由业务零碎自行来保障幂等性呢？集体认为，应该是由 TCC 事务框架来提供幂等性保障。如果仅仅只是极个别服务存在这个问题的话，那么由业务零碎来负责也是能够的；然而，这是一类公共问题，毫无疑问，所有 TCC 服务的 Confirm/Cancel 业务存在幂等性问题。TCC 服务的公共问题应该由 TCC 事务框架来解决；而且，考虑一下由业务零碎来负责幂等性须要思考的问题，就会发现，这无疑增大了业务零碎的复杂度。