Spring、SpringBoot、Redis、Mysql 事务管理机制汇总

╰半夏微凉° 2022-04-11 02:18 670阅读 0赞

**目录**

一、Spring事务管理之几种方式实现事务

二、SpringBoot事务管理

三、Redis的事务功能详解

（一）相关命令

1. MULTI

2. EXEC

3. DISCARD

4. WATCH

5. UNWATCH

（二）使用方法

（三）事务内部的错误

（四）为什么Redis不支持回滚？

（五）丢弃命令队列

（六）通过CAS操作实现乐观锁

（七）WATCH命令详解

（八）Redis脚本和事务

四、Mysql事务处理详解

（一）Mysql事务概念

（二）读取数据概念

（三）事务隔离级别

--------------------

# 一、Spring事务管理之几种方式实现事务 #

## 1、事务认识 ##

大家所了解的事务Transaction，它是一些列严密操作动作，要么都操作完成，要么都回滚撤销。Spring事务管理基于底层数据库本身的事务处理机制。数据库事务的基础，是掌握Spring事务管理的基础。这篇总结下Spring事务。  
事务具备ACID四种特性，ACID是Atomic（原子性）、Consistency（一致性）、Isolation（隔离性）和Durability（持久性）的英文缩写。  
（1）原子性（Atomicity）  
事务最基本的操作单元，要么全部成功，要么全部失败，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚到事务开始前的状态，就像这个事务从来没有执行过一样。  
（2）一致性（Consistency）  
事务的一致性指的是在一个事务执行之前和执行之后数据库都必须处于一致性状态。如果事务成功地完成，那么系统中所有变化将正确地应用，系统处于有效状态。如果在事务中出现错误，那么系统中的所有变化将自动地回滚，系统返回到原始状态。  
（3）隔离性（Isolation）  
指的是在并发环境中，当不同的事务同时操纵相同的数据时，每个事务都有各自的完整数据空间。由并发事务所做的修改必须与任何其他并发事务所做的修改隔离。事务查看数据更新时，数据所处的状态要么是另一事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看到中间状态的数据。  
（4）持久性（Durability）  
指的是只要事务成功结束，它对数据库所做的更新就必须永久保存下来。即使发生系统崩溃，重新启动数据库系统后，数据库还能恢复到事务成功结束时的状态。

##    2、事务的传播特性 ##

事务传播行为就是多个事务方法调用时，如何定义方法间事务的传播。Spring定义了7中传播行为：  
（1）propagation\_requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是Spring默认的选择。  
（2）propagation\_supports：支持当前事务，如果没有当前事务，就以非事务方法执行。  
（3）propagation\_mandatory：使用当前事务，如果没有当前事务，就抛出异常。  
（4）propagation\_required\_new：新建事务，如果当前存在事务，把当前事务挂起。  
（5）propagation\_not\_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。  
（6）propagation\_never：以非事务方式执行操作，如果当前事务存在则抛出异常。  
（7）propagation\_nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation\_required类似的操作。

##    3、事务的隔离级别 ##

（1）read uncommited：是最低的事务隔离级别，它允许另外一个事务可以看到这个事务未提交的数据。  
（2）read commited：保证一个事物提交后才能被另外一个事务读取。另外一个事务不能读取该事物未提交的数据。  
（3）repeatable read：这种事务隔离级别可以防止脏读，不可重复读。但是可能会出现幻象读。它除了保证一个事务不能被另外一个事务读取未提交的数据之外还避免了以下情况产生（不可重复读）。  
（4）serializable：这是花费最高代价但最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读之外，还避免了幻象读  
（5）脏读、不可重复读、幻象读概念说明：  
a.脏读：指当一个事务正字访问数据，并且对数据进行了修改，而这种数据还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据还没有提交那么另外一个事务读取到的这个数据我们称之为脏数据。依据脏数据所做的操作肯能是不正确的。  
b.不可重复读：指在一个事务内，多次读同一数据。在这个事务还没有执行结束，另外一个事务也访问该同一数据，那么在第一个事务中的两次读取数据之间，由于第二个事务的修改第一个事务两次读到的数据可能是不一样的，这样就发生了在一个事物内两次连续读到的数据是不一样的，这种情况被称为是不可重复读。  
c.幻象读：一个事务先后读取一个范围的记录，但两次读取的纪录数不同，我们称之为幻象读（两次执行同一条 select 语句会出现不同的结果，第二次读会增加一数据行，并没有说这两次执行是在同一个事务中）

##    4、事务几种实现方式 ##

（1）编程式事务管理对基于 POJO 的应用来说是唯一选择。我们需要在代码中调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。  
（2）基于 TransactionProxyFactoryBean的声明式事务管理  
（3）基于 @Transactional 的声明式事务管理  
（4）基于Aspectj AOP配置事务

##    5、举例说明事务不同实现 ##

编程式事务基本已经OUT了，在上上家公司的老工程还能找到，所有就省略了，主要回顾 下声明式事务。  
以用户购买股票为例  
新建用户对象、股票对象、以及dao、service层  
\---------------------   
作者：WilliamDream    
原文：[https://blog.csdn.net/chinacr07/article/details/78817449][https_blog.csdn.net_chinacr07_article_details_78817449]

**spring事务回滚规则**

指示spring事务管理器回滚一个事务的推荐方法是在当前事务的上下文内抛出异常。spring事务管理器会捕捉任何未处理的异常，然后依据规则决定是否回滚抛出异常的事务。

默认配置下，spring只有在抛出的异常为运行时unchecked异常时才回滚该事务，也就是抛出的异常为RuntimeException的子类(Errors也会导致事务回滚)，而抛出checked异常则不会导致事务回滚。  
可以明确的配置在抛出那些异常时回滚事务，包括checked异常。也可以明确定义那些异常抛出时不回滚事务。

还可以编程性的通过setRollbackOnly()方法来指示一个事务必须回滚，在调用完setRollbackOnly()后你所能执行的唯一操作就是回滚。

**@Transactional注解**

*@Transactional属性*

<table> &nbsp; 
 <thead> 
 <tr> 
 <th>属性</th> 
 <th>类型</th> 
 <th>描述</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td>value</td> 
 <td>String</td> 
 <td>可选的限定描述符，指定使用的事务管理器</td> 
 </tr> 
 <tr> 
 <td>propagation</td> 
 <td>enum: Propagation</td> 
 <td>可选的事务传播行为设置</td> 
 </tr> 
 <tr> 
 <td>isolation</td> 
 <td>enum: Isolation</td> 
 <td>可选的事务隔离级别设置</td> 
 </tr> 
 <tr> 
 <td>readOnly</td> 
 <td>boolean</td> 
 <td>读写或只读事务，默认读写</td> 
 </tr> 
 <tr> 
 <td>timeout</td> 
 <td>int (in seconds granularity)</td> 
 <td>事务超时时间设置</td> 
 </tr> 
 <tr> 
 <td>rollbackFor</td> 
 <td>Class对象数组，必须继承自Throwable</td> 
 <td>导致事务回滚的异常类数组</td> 
 </tr> 
 <tr> 
 <td>rollbackForClassName</td> 
 <td>类名数组，必须继承自Throwable</td> 
 <td>导致事务回滚的异常类名字数组</td> 
 </tr> 
 <tr> 
 <td>noRollbackFor</td> 
 <td>Class对象数组，必须继承自Throwable</td> 
 <td>不会导致事务回滚的异常类数组</td> 
 </tr> 
 <tr> 
 <td>noRollbackForClassName</td> 
 <td>类名数组，必须继承自Throwable</td> 
 <td>不会导致事务回滚的异常类名字数组</td> 
 </tr> 
 </tbody> 
</table>

*用法*

@Transactional 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。

虽然 @Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。另外， @Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。如果你在 protected、private 或者默认可见性的方法上使用 @Transactional 注解，这将被忽略，也不会抛出任何异常。

默认情况下，只有来自外部的方法调用才会被AOP代理捕获，也就是，类内部方法调用本类内部的其他方法并不会引起事务行为，即使被调用方法使用@Transactional注解进行修饰。

1 @Transactional(readOnly = true)
     2 public class DefaultFooService implements FooService {
     3  
     4   public Foo getFoo(String fooName) {
     5     // do something
     6   }
     7  
     8   // these settings have precedence for this method
     9   //方法上注解属性会覆盖类注解上的相同属性
    10   @Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)
    11   public void updateFoo(Foo foo) {
    12     // do something
    13   }
    14 }

# 二、SpringBoot事务管理 #

1、需要的注解为@EnableTransactionManagement 和@Transactional 两个，它们来自于下边这个包：

spring-tx.jar

该包其实在前边配置mybatis引入依赖时，已自动引入，就是下边这个：

<dependency>
 <groupId>org.mybatis.spring.boot</groupId>
 <artifactId>mybatis-spring-boot-starter</artifactId>
 <version>1.2.0</version>
 </dependency>

所以只要上边的依赖引入进来，那事务就不需要再引入包了，   
2.首先，找到你的service实现类，加上@Transactional 注解，如果你加在类上，那该类所有的方法都会被事务管理，如果你加在方法上，那仅仅该方法符合具体的事务。当然我们一般都是加在方法上。因为只有增、删、改才会需要事务。   
比如下边的一个插入数据的方法添加事务：

@Override
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout=36000,rollbackFor=Exception.class)
    public Integer add(Cbf_jtcy t) {
        return cbf_jtcyMapper.insert(t);
    }

如果不知道里边都是什么东西，可以查看这篇文章，spring,mybatis事务管理配置与@Transactional注解使用

3.配置完后，spring boot启动类必须要开启事务，而开启事务用的注解就是@EnableTransactionManagement ,如下：

@SpringBootApplication
    @EnableTransactionManagement 
    @MapperScan("microservice.qssj.mapper")//必须加这个，不加报错，如果不加，也可以在每个mapper上添加@Mapper注释，并且这里还要多填一个注释，那个我忘了，我一直用这个注解
    public class QssjServiceApplication {
        public static void main(String[] args) {
            SpringApplication.run(QssjServiceApplication.class, args);
        }
    }

这样就完成了事务的配置。  
\---------------------   
作者：JAVA码上飘    
原文：[https://blog.csdn.net/wohaqiyi/article/details/72895983][https_blog.csdn.net_wohaqiyi_article_details_72895983]

#  三、Redis的事务功能详解 #

MULTI、EXEC、DISCARD和WATCH命令是Redis事务功能的基础。Redis事务允许在一次单独的步骤中执行一组命令，并且可以保证如下两个重要事项：

>Redis会将一个事务中的所有命令序列化，然后按顺序执行。Redis不可能在一个Redis事务的执行过程中插入执行另一个客户端发出的请求。这样便能保证Redis将这些命令作为一个单独的隔离操作执行。 > 在一个Redis事务中，Redis要么执行其中的所有命令，要么什么都不执行。因此，Redis事务能够保证原子性。EXEC命令会触发执行事务中的所有命令。因此，当某个客户端正在执行一次事务时，如果它在调用MULTI命令之前就从Redis服务端断开连接，那么就不会执行事务中的任何操作；相反，如果它在调用EXEC命令之后才从Redis服务端断开连接，那么就会执行事务中的所有操作。当Redis使用只增文件（AOF：Append-only File）时，Redis能够确保使用一个单独的write(2)系统调用，这样便能将事务写入磁盘。然而，如果Redis服务器宕机，或者系统管理员以某种方式停止Redis服务进程的运行，那么Redis很有可能只执行了事务中的一部分操作。Redis将会在重新启动时检查上述状态，然后退出运行，并且输出报错信息。使用redis-check-aof工具可以修复上述的只增文件，这个工具将会从上述文件中删除执行不完全的事务，这样Redis服务器才能再次启动。

从2.2版本开始，除了上述两项保证之外，Redis还能够以乐观锁的形式提供更多的保证，这种形式非常类似于“检查再设置”（CAS：Check And Set）操作。本文稍后会对Redis的乐观锁进行描述。

## （一）相关命令 ##

### 1. MULTI ###

用于标记事务块的开始。Redis会将后续的命令逐个放入队列中，然后才能使用EXEC命令原子化地执行这个命令序列。

这个命令的运行格式如下所示：

MULTI

这个命令的返回值是一个简单的字符串，总是OK。

### 2. EXEC ###

在一个事务中执行所有先前放入队列的命令，然后恢复正常的连接状态。

当使用WATCH命令时，只有当受监控的键没有被修改时，EXEC命令才会执行事务中的命令，这种方式利用了检查再设置（CAS）的机制。

这个命令的运行格式如下所示：

EXEC

这个命令的返回值是一个数组，其中的每个元素分别是原子化事务中的每个命令的返回值。 当使用WATCH命令时，如果事务执行中止，那么EXEC命令就会返回一个Null值。

### 3. DISCARD ###

清除所有先前在一个事务中放入队列的命令，然后恢复正常的连接状态。

如果使用了WATCH命令，那么DISCARD命令就会将当前连接监控的所有键取消监控。

这个命令的运行格式如下所示：

DISCARD

这个命令的返回值是一个简单的字符串，总是OK。

### 4. WATCH ###

当某个事务需要按条件执行时，就要使用这个命令将给定的键设置为受监控的。

这个命令的运行格式如下所示：

WATCH key [key ...]

这个命令的返回值是一个简单的字符串，总是OK。

对于每个键来说，时间复杂度总是O(1)。

### 5. UNWATCH ###

清除所有先前为一个事务监控的键。

如果你调用了EXEC或DISCARD命令，那么就不需要手动调用UNWATCH命令。

这个命令的运行格式如下所示：

UNWATCH

这个命令的返回值是一个简单的字符串，总是OK。

时间复杂度总是O(1)。

## （二）使用方法 ##

使用MULTI命令便可以进入一个Redis事务。这个命令的返回值总是OK。此时，用户可以发出多个Redis命令。Redis会将这些命令放入队列，而不是执行这些命令。一旦调用EXEC命令，那么Redis就会执行事务中的所有命令。

相反，调用DISCARD命令将会清除事务队列，然后退出事务。

以下示例会原子化地递增foo键和bar键的值：

![<img>][img]

正如从上面的会话所看到的一样，EXEC命令的返回值是一个数组，其中的每个元素都分别是事务中的每个命令的返回值，返回值的顺序和命令的发出顺序是相同的。

当一个Redis连接正处于MULTI请求的上下文中时，通过这个连接发出的所有命令的返回值都是QUEUE字符串（从Redis协议的角度来看，返回值是作为状态回复（Status Reply）来发送的）。当调用EXEC命令时，Redis会简单地调度执行事务队列中的命令。

## （三）事务内部的错误 ##

在一个事务的运行期间，可能会遇到两种类型的命令错误：

> 一个命令可能会在被放入队列时失败。因此，事务有可能在调用EXEC命令之前就发生错误。例如，这个命令可能会有语法错误（参数的数量错误、命令名称错误，等等），或者可能会有某些临界条件（例如：如果使用maxmemory指令，为Redis服务器配置内存限制，那么就可能会有内存溢出条件）。   
> 在调用EXEC命令之后，事务中的某个命令可能会执行失败。例如，我们对某个键执行了错误类型的操作（例如，对一个字符串（String）类型的键执行列表（List）类型的操作）。

可以使用Redis客户端检测第一种类型的错误，在调用EXEC命令之前，这些客户端可以检查被放入队列的命令的返回值：如果命令的返回值是QUEUE字符串，那么就表示已经正确地将这个命令放入队列；否则，Redis将返回一个错误。如果将某个命令放入队列时发生错误，那么大多数客户端将会中止事务，并且丢弃这个事务。

然而，从Redis 2.6.5版本开始，服务器会记住事务积累命令期间发生的错误。然后，Redis会拒绝执行这个事务，在运行EXEC命令之后，便会返回一个错误消息。最后，Redis会自动丢弃这个事务。

在Redis 2.6.5版本之前，如果发生了上述的错误，那么在客户端调用了EXEC命令之后，Redis还是会运行这个出错的事务，执行已经成功放入事务队列的命令，而不会关心先前发生的错误。从2.6.5版本开始，Redis在遭遇上述错误时，会采用先前描述的新行为，这样便能轻松地混合使用事务和管道。在这种情况下，客户端可以一次性地将整个事务发送至Redis服务器，稍后再一次性地读取所有的返回值。

相反，在调用EXEC命令之后发生的事务错误，Redis不会进行任何特殊处理：在事务运行期间，即使某个命令运行失败，所有其他的命令也将会继续执行。

这种行为在协议层面上更加清晰。在以下示例中，当事务正在运行时，有一条命令将会执行失败，即使这条命令的语法是正确的：

![<img>][img 1]

上述示例的EXEC命令的返回值是批量的字符串，包含两个元素，一个是OK代码，另一个是-ERR错误消息。客户端会根据自身的程序库，选择一种合适的方式，将错误信息提供给用户

需要注意的是，即使某个命令执行失败，事务队列中的所有其他命令仍然会执行 —— Redis不会停止执行事务中的命令。

再看另一个示例，再次使用telnet通信协议，观察命令的语法错误是如何尽快报告给用户的：

![<img>][img 2]

这一次，由于INCR命令的语法错误，Redis根本就没有将这个命令放入事务队列。

## （四）为什么Redis不支持回滚？ ##

如果你具备关系型数据库的知识背景，你就会发现一个事实：在事务运行期间，虽然Redis命令可能会执行失败，但是Redis仍然会执行事务中余下的其他命令，而不会执行回滚操作，你可能会觉得这种行为很奇怪。

然而，这种行为也有其合理之处：

> 只有当被调用的Redis命令有语法错误时，这条命令才会执行失败（在将这个命令放入事务队列期间，Redis能够发现此类问题），或者对某个键执行不符合其数据类型的操作：实际上，这就意味着只有程序错误才会导致Redis命令执行失败，这种错误很有可能在程序开发期间发现，一般很少在生产环境发现。   
> Redis已经在系统内部进行功能简化，这样可以确保更快的运行速度，因为Redis不需要事务回滚的能力。

对于Redis事务的这种行为，有一个普遍的反对观点，那就是程序有可能会有缺陷（bug）。但是，你应当注意到：事务回滚并不能解决任何程序错误。例如，如果某个查询会将一个键的值递增2，而不是1，或者递增错误的键，那么事务回滚机制是没有办法解决这些程序问题的。请注意，没有人能解决程序员自己的错误，这种错误可能会导致Redis命令执行失败。正因为这些程序错误不大可能会进入生产环境，所以我们在开发Redis时选用更加简单和快速的方法，没有实现错误回滚的功能。

## （五）丢弃命令队列 ##

DISCARD命令可以用来中止事务运行。在这种情况下，不会执行事务中的任何命令，并且会将Redis连接恢复为正常状态。示例如下所示：

![<img>][img 3]

## （六）通过CAS操作实现乐观锁 ##

Redis使用WATCH命令实现事务的“检查再设置”（CAS）行为。

作为WATCH命令的参数的键会受到Redis的监控，Redis能够检测到它们的变化。在执行EXEC命令之前，如果Redis检测到至少有一个键被修改了，那么整个事务便会中止运行，然后EXEC命令会返回一个Null值，提醒用户事务运行失败。

例如，设想我们需要将某个键的值自动递增1（假设Redis没有INCR命令）。

首次尝试的伪码可能如下所示：

val = GET mykey
    val = val + 1
    SET mykey $val

如果我们只有一个Redis客户端在一段指定的时间之内执行上述伪码的操作，那么这段伪码将能够可靠的工作。如果有多个客户端大约在同一时间尝试递增这个键的值，那么将会产生竞争状态。例如，客户端-A和客户端-B都会读取这个键的旧值（例如：10）。这两个客户端都会将这个键的值递增至11，最后使用SET命令将这个键的新值设置为11。因此，这个键的最终值是11，而不是12。

现在，我们可以使用WATCH命令完美地解决上述的问题，伪码如下所示：

WATCH mykey
    val = GET mykey
    val = val + 1
    MULTI
    SET mykey $val
    EXEC

由上述伪码可知，如果存在竞争状态，并且有另一个客户端在我们调用WATCH命令和EXEC命令之间的时间内修改了val变量的结果，那么事务将会运行失败。

我们只需要重复执行上述伪码的操作，希望此次运行不会再出现竞争状态。这种形式的锁就被称为乐观锁，它是一种非常强大的锁。在许多用例中，多个客户端可能会访问不同的键，因此不太可能发生冲突 —— 也就是说，通常没有必要重复执行上述伪码的操作。

## （七）WATCH命令详解 ##

那么WATCH命令实际做了些什么呢？这个命令会使得EXEC命令在满足某些条件时才会运行事务：我们要求Redis只有在所有受监控的键都没有被修改时，才会执行事务。（但是，相同的客户端可能会在事务内部修改这些键，此时这个事务不会中止运行。）否则，Redis根本就不会进入事务。（注意，如果你使用WATCH命令监控一个易失性的键，然后在你监控这个键之后，Redis再使这个键过期，那么EXEC命令仍然可以正常工作。）

WATCH命令可以被调用多次。简单说来，所有的WATCH命令都会在被调用之时立刻对相应的键进行监控，直到EXEC命令被调用之时为止。你可以在单条的WATCH命令之中，使用任意数量的键作为命令参数。

当调用EXEC命令时，所有的键都会变为未受监控的状态，Redis不会管事务是否被中止。当一个客户单连接被关闭时，所有的键也都会变为未受监控的状态。

你还可以使用UNWATCH命令（不需要任何参数），这样便能清除所有的受监控键。当我们对某些键施加乐观锁之后，这个命令有时会非常有用。因为，我们可能需要运行一个用来修改这些键的事务，但是在读取这些键的当前内容之后，我们可能不打算继续进行操作，此时便可以使用UNWATCH命令，清除所有受监控的键。在运行UNWATCH命令之后，Redis连接便可以再次自由地用于运行新事务。

如何使用WATCH命令实现ZPOP操作呢？

本文将通过一个示例，说明如何使用WATCH命令创建一个新的原子化操作（Redis并不原生支持这个原子化操作），此处会以实现ZPOP操作为例。这个命令会以一种原子化的方式，从一个有序集合中弹出分数最低的元素。以下源码是最简单的实现方式：

WATCH zset
    element = ZRANGE zset 0 0
    MULTI
    ZREM zset element
    EXEC

如果伪码中的EXEC命令执行失败（例如，返回Null值），那么我们只需要重复运行这个操作即可。

## （八）Redis脚本和事务 ##

根据定义，Redis脚本也是事务型的。因此，你可以通过Redis事务实现的功能，同样也可以通过Redis脚本来实现，而且通常脚本更简单、更快速。

由于Redis从2.6版本才开始引入脚本特性，而事务特性是很久以前就已经存在的，所以目前的版本才有两个看起来重复的特性。但是，我们不太可能在短时间内移除对事务特性的支持。因为，即使不用求助于Redis脚本，用户仍然能够规避竞争状态，这从语义上来看是适宜的。还有另一个更重要的原因，Redis事务特性的实现复杂度是最小的。

但是，在相当长的一段时间之内，我们不大可能看到整个用户群体都只使用Redis脚本。如果发生这种情况，那么我们可能会废弃，甚至最终移除Redis事务。

原文：[https://www.cnblogs.com/kyrin/p/5967620.html][https_www.cnblogs.com_kyrin_p_5967620.html]

# 四、Mysql事务处理详解 #

## **（一）Mysql事务概念** ##

MySQL 事务主要用于处理操作量大，复杂度高的数据。由一步或几步数据库操作序列组成逻辑执行单元，这系列操作要么全部执行，要么全部放弃执行。在 MySQL 中只有使用了 Innodb 数据库引擎的数据库或表才支持事务。事务用来管理 insert,update,delete 语句。

## **（二）读取数据概念** ##

1.脏读（Dirty Reads）：所谓脏读就是对脏数据的读取，而脏数据所指的就是未提交的数据。一个事务正在对一条记录做修改，在这个事务完成并提交之前，这条数据是处于待定状态的（可能提交也可能回滚），这时，第二个事务来读取这条没有提交的数据，并据此做进一步的处理，就会产生未提交的数据依赖关系。这种现象被称为脏读。

2.不可重复读（Non-Repeatable Reads）：一个事务先后读取同一条记录，但两次读取的数据不同，我们称之为不可重复读。也就是说，这个事务在两次读取之间该数据被其它事务所修改。

3.幻读（Phantom Reads）：一个事务按相同的查询条件重新读取以前检索过的数据，却发现其他事务插入了满足其查询条件的新数据，这种现象就称为幻读。

## **（三）事务隔离级别** ##

修改事务隔离级别语法：  
　　SET \[SESSION | GLOBAL\] TRANSACTION ISOLATION LEVEL \{READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE\}

1、Read Uncommitted(未授权读取、读未提交)：这是最低的隔离等级，允许其他事务看到没有提交的数据。这种等级会导致脏读。如果一个事务已经开始写数据，则另外一个事务则不允许同时进行写操作，但允许其他事务读此行数据。该隔离级别可以通过“排他写锁”实现。避免了更新丢失，却可能出现脏读。也就是说事务B读取到了事务A未提交的数据。SELECT语句以非锁定方式被执行，所以有可能读到脏数据，隔离级别最低。

[?][Link 1]

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 </td> 
 <td> <code>SET</code> <code>session </code><code>transaction</code> <code>isolation</code> <code>level</code> <code>read</code> <code>uncommitted</code> <code>;</code> <code>SET</code> <code>global</code> <code>transaction</code> <code>isolation</code> <code>level</code> <code>read</code> <code>uncommitted</code><code>;/*全局建议不用*/</code> <code>SELECT</code> <code>@@</code><code>global</code><code>.tx_isolation;</code> <code>SELECT</code> <code>@@session.tx_isolation;</code> <code>SELECT</code> <code>@@tx_isolation;</code> </td> 
 </tr> 
 </tbody> 
</table>

新建一个简单的student表，设置id和name,num字段，开启事务1对表新增通过存储过程，事务不提交，查看当前数据库事务状态,可以看到一条数据事务，事务级别为READ UNCOMMITTED：

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 </td> 
 <td> <code>drop</code> <code>table</code> <code>if exists student;</code> <code>create</code> <code>table</code> <code>student(</code> <code>id </code><code>int</code> <code>primary</code> <code>key</code> <code>auto_increment comment </code><code>'id'</code><code>,</code> <code>name</code> <code>varchar</code><code>(100) comment </code><code>'名称'</code><code>,</code> <code>num </code><code>int</code> <code>);</code> <code>drop</code> <code>procedure</code> <code>if exists proc_on_sw;</code> <code>delimiter ;;</code> <code>create</code> <code>procedure</code> <code>proc_on_sw()</code> <code>begin</code> <code>start </code><code>transaction</code><code>;</code> <code>insert</code> <code>into</code> <code>student(</code><code>name</code><code>,num) value(</code><code>'aaa'</code><code>,1);</code> <code>select</code> <code>* </code><code>from</code> <code>information_schema.INNODB_TRX;</code> <code>end</code> <code>;;</code> <code>delimiter ;;</code> <code>call proc_on_sw();</code> </td> 
 </tr> 
 </tbody> 
</table>

新建事务2，查询student表，我们在READ UNCOMMITTED级别下，可以看到其他事务未提交的数据：再去查看数据库事务状态，我们会看到状态正常。

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 </td> 
 <td> <code>start </code><code>transaction</code> <code>;</code> <code>select</code> <code>* </code><code>from</code> <code>student;</code> <code>commit</code><code>;</code> <code>select</code> <code>* </code><code>from</code> <code>information_schema.INNODB_TRX;</code> </td> 
 </tr> 
 </tbody> 
</table>

2.Read Committed(授权读取、读提交):读取数据的事务允许其他事务继续访问该行数据，但是未提交的写事务将会禁止其他事务访问该行。该隔离级别避免了脏读，但是却可能出现不可重复读。事务A事先读取了数据，事务B紧接了更新了数据，并提交了事务，而事务A再次读取该数据时，数据已经发生了改变。

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 </td> 
 <td> <code>SET</code> <code>session </code><code>transaction</code> <code>isolation</code> <code>level</code> <code>read</code> <code>committed</code> <code>;</code> <code>SET</code> <code>global</code> <code>transaction</code> <code>isolation</code> <code>level</code> <code>read</code> <code>committed</code><code>; /*全局建议不用*/</code> &nbsp; <code>drop</code> <code>procedure</code> <code>if exists proc_on_up;</code> <code>delimiter ;;</code> <code>create</code> <code>procedure</code> <code>proc_on_up()</code> <code>begin</code> <code>set</code> <code>autocommit=0;</code> <code>update</code> <code>student </code><code>set</code> <code>name</code><code>=</code><code>'cc'</code> <code>where</code> <code>id=1;</code> <code>commit</code><code>;</code> <code>set</code> <code>autocommit=1;</code> <code>end</code> <code>;;</code> <code>delimiter ;;</code> <code>call proc_on_up();</code> <code>select</code> <code>* </code><code>from</code> <code>student;</code> </td> 
 </tr> 
 </tbody> 
</table>

3.repeatable read(可重复读取):就是在开始读取数据（事务开启）时，不再允许修改操作,事务开启，不允许其他事务的UPDATE修改操作，不可重复读对应的是修改，即UPDATE操作。但是可能还会有幻读问题。因为幻读问题对应的是插入INSERT操作，而不是UPDATE操作。避免了不可重复读取和脏读，但是有时可能出现幻读。这可以通过“共享读锁”和“排他写锁”实现。

`set session transaction isolation level repeatable read;`

4.串行化、序列化：提供严格的事务隔离。它要求事务序列化执行，事务只能一个接着一个地执行，但不能并发执行。如果仅仅通过“行级锁”是无法实现事务序列化的，必须通过其他机制保证新插入的数据不会被刚执行查询操作的事务访问到。序列化是最高的事务隔离级别，同时代价也花费最高，性能很低，一般很少使用，在该级别下，事务顺序执行，不仅可以避免脏读、不可重复读，还避免了幻像读。

`set session transaction isolation level serializable;`

隔离等级 　　脏读 　　不可重复读　　 幻读  
　　　　　　读未提交 　　YES　　 YES 　　　　　YES  
　　　　　　读已提交 　　NO 　　 YES 　　　　    YES  
　　　　　　可重复读 　　NO 　　 NO　　　　　   YES  
　　　　　　串行化 　　    NO 　　 NO 　　　　　  NO

五、完整例子包括提交和回滚完整例子

<table> 
 <tbody> 
 <tr> 
 <td> 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 </td> 
 <td> <code>drop</code> <code>procedure</code> <code>if exists pro_new;</code> <code>delimiter;;</code> <code>create</code> <code>procedure</code> <code>pro_new(</code><code>out</code> <code>rtn </code><code>int</code><code>)</code> <code>begin</code> <code>declare</code> <code>err </code><code>INT</code> <code>default</code> <code>0;</code> <code>-- 如果出现异常，会自动处理并rollback</code> <code>declare</code> <code>exit handler </code><code>for</code> <code>sqlexception </code><code>ROLLBACK</code> <code>; </code> <code>-- 启动事务</code> <code>set</code> <code>autocommit=0;</code> <code>start </code><code>transaction</code><code>;</code> <code>insert</code> <code>into</code> <code>student(</code><code>name</code><code>,num) </code><code>values</code><code>(</code><code>NULL</code><code>,2.3);</code> <code>-- set err = @@IDENTITY; -- =&nbsp; 获取上一次插入的自增ID;</code> <code>set</code> <code>err =last_insert_id(); </code><code>-- 获取上一次插入的自增ID</code> <code>insert</code> <code>into</code> <code>student(</code><code>name</code><code>,num) </code><code>VALUEs</code><code>(</code><code>'ccc'</code><code>,err);</code> <code>-- 运行没有异常，提交事务</code> <code>commit</code><code>;</code> <code>-- 设置返回值为1</code> <code>set</code> <code>rtn=1;</code> <code>set</code> <code>autocommit=1;</code> <code>end</code> <code>;;</code> <code>delimiter ;;</code> <code>set</code> <code>@n=1;</code> <code>call pro_new(@n);</code> <code>select</code> <code>@n;</code> </td> 
 </tr> 
 </tbody> 
</table>

原文：[https://www.jb51.net/article/121153.htm][https_www.jb51.net_article_121153.htm]

[https_blog.csdn.net_chinacr07_article_details_78817449]: https://blog.csdn.net/chinacr07/article/details/78817449
[https_blog.csdn.net_wohaqiyi_article_details_72895983]: https://blog.csdn.net/wohaqiyi/article/details/72895983
[img]: /images/20220411/d27e31c0a9824aa6a76ecfda2a8f4d6a.png
[img 1]: /images/20220411/0eb19dfc54f34da08556372ca0123472.png
[img 2]: /images/20220411/bb10da61f64941b5a227a040082228c4.png
[img 3]: /images/20220411/bb31cf10419a481a9135299e90753377.png
[https_www.cnblogs.com_kyrin_p_5967620.html]: https://www.cnblogs.com/kyrin/p/5967620.html
[Link 1]: https://www.jb51.net/article/121153.htm#
[https_www.jb51.net_article_121153.htm]: https://www.jb51.net/article/121153.htm