面试必问的分布式事务：1.1-概念以及解决方案

首先说说数据库事务的一些特性

1：数据库事务

1.1事务的几个特性

事务提供了一种机制，可用来将一系列数据库更改归入一个逻辑操作。更改数据库后，所做的更改可以作为一个单元进行提交或取消。事务可确保遵循原子性、一致性、隔离性和持续性（ACID）这几种属性，以使数据能够正确地提交到数据库中。

        1）原子性：原子性是指事务是一个不可分割的工作单位，事务中的操作 要么都发生，要么都不发生。

        2）一致性：一个事务中，事务前后数据的完整性必须保持一致。

        3）隔离性：多个事务，事务的隔离性是指多个用户并发访问数据库时， 一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。

       4）持久性：指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。

1.2并发事务产生的影响

1.脏读

一个事务正在对数据进行更新操作，但是更新还未提交，另一个事务这时也来操作这组数据，并且读取了前一个事务还未提交的数据，而前一个事务如果操作失败进行了回滚，后一个事务读取的就是错误的数据，这样就造成了脏读

2.不可重复读

     一个事务多次读取同一个数据，在该事务还未结束时，另一个事务也对该数据进行了操作，而且在第一个事务两次读取之间，第二个事务对数据进行了更新，那么第一个事务前后两个读取到的数据是不同的，这样就造成了不可重复读

3.幻读

第一个数据正在查询某一条数据，这时，另一个事务又插入了一条符合条件的数据，第一个事务在第二次查询符合同一条件的数据时，发现多了一条前一次查询时没有的数据，仿佛幻觉一样，这就是幻读

总结来说就是：

    脏读（T2更新回滚了，T1在读，没有了）（更新未提交）

    不可重复读（T2更新字段，T1在读，值不同）（更新：更新了值）

    幻读（T2插入新的行，T1在读，多几行）（新增：多了几行）

其中：

    不可重复读的重点是修改 :

        同样的条件 , 你读取过的数据 , 再次读取出来发现值不一样了

    幻读的重点在于新增或者删除

        同样的条件 , 第 1 次和第 2 次读出来的记录数不一样

1.3事务的隔离级别

1.default：(默认)

默认隔离级别，使用数据库默认的事务隔离级别

2.read_uncommitted:(读未提交)

这是事务最低的隔离级别,他允许另外一个事务可以看到这个事务未提交的数据,这种隔离级别会产生脏读,不可重复读和幻读

3.read_committed(读已提交)

保证一个事务修改的数据提交后才能被另外一个事务读取,另外一个事务不能读取该事务未提交的数据.这种事务隔离级别可以避免脏读,但是可能会出现不可重复读和幻读

4.repeatable_read(可重复读)

这种事务级别可以防止脏读,不可重复读.但是可能出现幻读.他除了保证一个事务不能读取另一个事务未提交的数据外,还保证了不可重复读

5.Serializable 串行化

这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。防止了脏读、不可重复读、幻读

 

1.4事务的传播行为

事务的传播行为：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。

例如：方法可能继续在现有的事务中运行，也有可能开启一个新的事务，并在自己的事务中运行。

 

事务的传播行为可以有传播属性（7种）指定。

1：required : 如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行。

如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。

2：required_new : 当前方法必须启动新事务，并在它自己的事务内运行。如果有事务在运行，应该将它挂起。创建一个新的事务，如果当前存在事务，则把当前事务挂起。

 

@Transactional(propagation=Propagation.REQUIRED）

使用propagation 指定事务的传播行为。[,prɒpə'ɡeɪʃən] 。既当前的事务方法被另外一个事务方法调用时如何使用事务。

 

默认为requred：既默认使用调用方法的事务。

requred_new ： 使用自己的事务。调用的事务方法的事务被挂起。

一般只要知道这两个就行了，最常用的！！！！

 

可以分类：

第一类：如果已经存在事务，三种处理方式。

required 需要 ： 如果存在一个事务，则支持当前事务。如果没有事务则开启。

support 支持 ： 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。

（支持： 你有的话我就支持，没有我就不支持）

mandatory 必须的 ： 如果已经存在一个事务，支持当前事务。如果没有，则抛出异常。

（必须有一个事务）

 

第二类：

required_new : 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

not_support : 总是非事务的执行，并挂起任何存在的事务。

never 绝不 : 总是非事务的执行，如果存在一个活动事务，则抛出异常。

（绝不： 意思是绝不需要事务）

nested 嵌套的 ： 如果一个活动的事务存在，则运行在一个嵌套的事务中。

如果没有活动事务，则按照required执行。

（其实意思就是：如果有就嵌套，没有就开启事务。）

 

2：分布式事务

2.1分布式理论

2.1.1CAP理论

在分布式系统中，一致性(Consistency)、可用性(Availability)和分区容忍性(Partition Tolerance)3个要素最多只能同时满足两个，不可兼得。其中，分区容忍性又是不可或缺的。

• 一致性：分布式环境下，多个节点的数据是否强一致。
• 可用性：分布式服务能一直保证可用状态。当用户发出一个请求后，服务能在有限时间内返回结果。
• 分区容忍性：特指对网络分区的容忍性。

举例：Cassandra、Dynamo 等，默认优先选择 AP，弱化 C;

HBase、MongoDB 等，默认优先选择 CP，弱化 A。

 

关系型数据库选择CA

非关系型数据库选择CP

 

2.1.2BASE理论

在分布式系统中，我们往往追求的是可用性，它的重要程序比一致性要高，那么如何实现高可用性呢？ 前人已经给我们提出来了另外一个理论，就是BASE理论，它是用来对CAP定理进行进一步扩充的。BASE理论指的是：

核心思想：保证最终一致性

• 基本可用(Basically Available)：指分布式系统在出现故障时，允许损失部分的可用性来保证核心可用。
• 软状态(Soft State)：指允许分布式系统存在中间状态，该中间状态不会影响到系统的整体可用性。
• 最终一致性(Eventual Consistency)：指分布式系统中的所有副本数据经过一定时间后，最终能够达到一致的状态。

 

理论的核心思想就是：我们无法做到强一致，但每个应用都可以根据自身的业务特点，采用适当的方式来使系统达到最终一致性

 

2.2分布式事务

一般来说，分布式事务的实现主要有以下 5 种方案：

• XA 方案（两阶段提交）
• 本地消息表（ebay ）（消息队列）
• TCC 方案（补偿事务）：采用补偿机制
• 可靠消息最终一致性方案（mq）（最终一致性）
• 最大努力通知方案

2.2.1两阶段提交XA

两阶段提交，有一个事务管理器的概念，负责协调多个数据库的事务，

    事务管理器先问问各个数据库你准备好了吗？

    如果每个数据库都回复 ok，那么就正式提交事务，在各个数据库上执行操作；

    如果任何其中一个数据库回答不 ok，那么就回滚事务。

这种分布式事务方案，比较适合单块应用里，跨多个库的分布式事务，而且因为严重依赖于数据库层面来搞定复杂的事务，效率很低，绝对不适合高并发的场景。

这个方案，我们很少用，一般来说某个系统内部如果出现跨多个库的这么一个操作，是不合规的。我可以给大家介绍一下， 现在微服务，一个大的系统分成几十个甚至几百个服务。一般来说，我们的规定和规范，是要求每个服务只能操作自己对应的一个数据库。

如果你要操作别的服务对应的库，不允许直连别的服务的库，违反微服务架构的规范，你随便交叉胡乱访问，几百个服务的话，全体乱套，这样的一套服务是没法管理的，没法治理的，可能会出现数据被别人改错，自己的库被别人写挂等情况。

 

如果你要操作别人的服务的库，你必须是通过调用别的服务的接口来实现，绝对不允许交叉访问别人的数据库。

 

两段提交就是分两个阶段提交，

第一阶段询问各个事务数据源是否准备好，

第二阶段才真正将数据提交给事务数据源。

为了保证该事务可以满足ACID，就要引入一个协调者。

其他的节点被称为参与者。

协调者负责调度参与者的行为，并最终决定这些参与者是否要把事务进行提交。

问题

1) 性能问题：所有参与者在事务提交阶段处于同步阻塞状态，占用系统资源，容易导致性能瓶颈。

2) 可靠性问题：如果协调者存在单点故障问题，或出现故障，提供者将一直处于锁定状态。

3) 数据一致性问题：在阶段 2 中，如果出现协调者和参与者都挂了的情况，有可能导致数据不一致。

 

优点：尽量保证了数据的强一致，适合对数据强一致要求很高的关键领域。（其实也不能100%保证强一致）。

缺点：实现复杂，牺牲了可用性，对性能影响较大，不适合高并发高性能场景。

 

2.2.2TCC方案

TCC 的全称是：Try、Confirm、Cancel。

• Try 阶段：这个阶段说的是对各个服务的资源做检测以及对资源进行锁定或者预留。
• Confirm 阶段：这个阶段说的是在各个服务中执行实际的操作。
• Cancel 阶段：如果任何一个服务的业务方法执行出错，那么这里就需要进行补偿，就是执行已经执行成功的业务逻辑的回滚操作。（把那些执行成功的回滚）

这种方案说实话几乎很少人使用，我们用的也比较少，但是也有使用的场景。

因为这个事务回滚实际上是严重依赖于你自己写代码来回滚和补偿了，会造成补偿代码巨大，非常之恶心。

比如说我们，一般来说跟钱相关的，跟钱打交道的，支付、交易相关的场景，我们会用 TCC，严格保证分布式事务要么全部成功，要么全部自动回滚，严格保证资金的正确性，保证在资金上不会出现问题。

而且最好是你的各个业务执行的时间都比较短。

但是说实话，一般尽量别这么搞，自己手写回滚逻辑，或者是补偿逻辑，实在太恶心了，那个业务代码很难维护。

优点：

性能提升：具体业务来实现控制资源锁的粒度变小，不会锁定整个资源。

数据最终一致性：基于 Confirm 和 Cancel 的幂等性，保证事务最终完成确认或者取消，保证数据的一致性。

可靠性：解决了 XA 协议的协调者单点故障问题，由主业务方发起并控制整个业务活动，业务活动管理器也变成多点，引入集群。

缺点：TCC 的 Try、Confirm 和 Cancel 操作功能要按具体业务来实现，业务耦合度较高，提高了开发成本。

 

2.2.3本地消息表

本地消息表其实是国外的 ebay 搞出来的这么一套思想。

这个大概意思是这样的：

1. A 系统在自己本地一个事务里操作同时，插入一条数据到消息表；
2. 接着 A 系统将这个消息发送到 MQ 中去；
3. B 系统接收到消息之后，在一个事务里，往自己本地消息表里插入一条数据，同时执行其他的业务操作，如果这个消息已经被处理过了，那么此时这个事务会回滚，这样保证不会重复处理消息；
4. B 系统执行成功之后，就会更新自己本地消息表的状态以及 A 系统消息表的状态；
5. 如果 B 系统处理失败了，那么就不会更新消息表状态，那么此时 A 系统会定时扫描自己的消息表，如果有未处理的消息，会再次发送到 MQ 中去，让 B 再次处理；
6. 这个方案保证了最终一致性，哪怕 B 事务失败了，但是 A 会不断重发消息，直到 B 那边成功为止。

这个方案说实话最大的问题就在于严重依赖于数据库的消息表来管理事务啥的，会导致如果是高并发场景咋办呢？咋扩展呢？所以一般确实很少用。

 

其核心思想是将分布式事务拆分成本地事务进行处理。

方案通过在消费者额外新建事务消息表，消费者处理业务和记录事务消息在本地事务中完成，轮询事务消息表的数据发送事务消息，提供者基于消息中间件消费事务消息表中的事务。

优点：从应用设计开发的角度实现了消息数据的可靠性，消息数据的可靠性不依赖于消息中间件，弱化了对 MQ 中间件特性的依赖。

缺点：与具体的业务场景绑定，耦合性强，不可公用。消息数据与业务数据同库，占用业务系统资源。业务系统在使用关系型数据库的情况下，消息服务性能会受到关系型数据库并发性能的局限。

 

2.2.4可靠消息最终一致性方案（MQ）

这个的意思，就是干脆不要用本地的消息表了，直接基于 MQ 来实现事务。

 

比如阿里的 RocketMQ 就支持消息事务。

大概的意思就是：

1. A 系统先发送一个 prepared 消息到 mq，如果这个 prepared 消息发送失败那么就直接取消操作别执行了；
2. 如果这个消息发送成功过了，那么接着执行本地事务，如果成功就告诉 mq 发送确认消息，如果失败就告诉 mq 回滚消息；
3. 如果发送了确认消息，那么此时 B 系统会接收到确认消息，然后执行本地的事务；
4. mq 会自动定时轮询所有 prepared 消息回调你的接口，问你，这个消息是不是本地事务处理失败了，所有没发送确认的消息，是继续重试还是回滚？一般来说这里你就可以查下数据库看之前本地事务是否执行，如果回滚了，那么这里也回滚吧。这个就是避免可能本地事务执行成功了，而确认消息却发送失败了。
5. 这个方案里，要是系统 B 的事务失败了咋办？重试咯，自动不断重试直到成功，如果实在是不行，要么就是针对重要的资金类业务进行回滚，比如 B 系统本地回滚后，想办法通知系统 A 也回滚；或者是发送报警由人工来手工回滚和补偿。
6. 这个还是比较合适的，目前国内互联网公司大都是这么玩儿的，要不你举用 RocketMQ 支持的，要不你就自己基于类似 ActiveMQ？RabbitMQ？自己封装一套类似的逻辑出来，总之思路就是这样子的。

MQ事务消息（最终一致性）

支持事务消息的MQ，其支持事务消息的方式采用类似于二阶段提交。

基于 MQ 的分布式事务方案其实是对本地消息表的封装，将本地消息表基于 MQ 内部，其他方面的协议基本与本地消息表一致。

 

优点：

消息数据独立存储，降低业务系统与消息系统之间的耦合。

吞吐量优于本地消息表方案。

缺点：

一次消息发送需要两次网络请求(half消息 + commit/rollback)。

需要实现消息回查接口。

 

2.2.5最大努力通知方案

这个方案的大致意思就是：

1. 系统 A 本地事务执行完之后，发送个消息到 MQ；
2. 这里会有个专门消费 MQ 的最大努力通知服务，这个服务会消费 MQ 然后写入数据库中记录下来，或者是放入个内存队列也可以，接着调用系统 B 的接口；
3. 要是系统 B 执行成功就 ok 了；要是系统 B 执行失败了，那么最大努力通知服务就定时尝试重新调用系统 B，反复 N 次，最后还是不行就放弃。

 

你们公司是如何处理分布式事务的？

如果你真的被问到，可以这么说，我们某某特别严格的场景，用的是 TCC 来保证强一致性；然后其他的一些场景基于阿里的 RocketMQ 来实现分布式事务。

你找一个严格资金要求绝对不能错的场景，你可以说你是用的 TCC 方案；

如果是一般的分布式事务场景，订单插入之后要调用库存服务更新库存，库存数据没有资金那么的敏感，可以用可靠消息最终一致性方案（也就是mq）。

友情提示一下，RocketMQ 3.2.6 之前的版本，是可以按照上面的思路来的，但是之后接口做了一些改变，我这里不再赘述了。

当然如果你愿意，你可以参考可靠消息最终一致性方案来自己实现一套分布式事务，比如基于 RocketMQ 来玩儿。