MySql 事务特性ACID、并发读、事务隔离级别

本是古典何须时尚 2021-10-19 01:18 420阅读 0赞

### 文章目录 ###

*  1、事务特性ACID
 *   *  1.1 原子性 Atomicity
     *  1.2.一致性 Consistency
     *  1.3.隔离性 Isolation
     *  1.4.持久性Duration
 *  2.并发读
 *   *  2.1.脏读
     *  2.2.不可重复读
     *  2.3.幻读
     *  2.4 解决方案
     *  2.5 事务隔离方式实现
 *  三、事务隔离级别
 *   *  3.1.读未提交 Read Uncommitted
     *  3.2.读已提交 Read Committed
     *  3.3.可重复读Repeatable Read
     *  3.4.可串行化Serializable
     *  3.5.三种并发读与四种事务隔离级别的总结
     *  3.6.隔离级别的查看与设置
     *   *  3.6.1.查看
         *  3.6.2.mysql设置
         *  3.6.3.java设置

# 1、事务特性ACID #

## 1.1 原子性 Atomicity ##

*  事务的所有操作，要么全部执行，要么全部不执行，不存在部分执行成功的情况。
 *  如果执行过程中出错，则应该回滚`rollback`到事务开始前的状态。
 *  事务是一个不可分割的整体。

## 1.2.一致性 Consistency ##

一致性：事务执行完成之后，数据应该满足完整性约束。

举例：事务执行前A、B的存款都是100，事务内容是A转账B，则事务执行完成之后，需要满足A和B的存款和还是200。

## 1.3.隔离性 Isolation ##

隔离性：不用的事务之间互不干扰。

隔离级别：关于数据的隔离性，MySql提供了四种级别，后文详细说明。

## 1.4.持久性Duration ##

持久性：事务一旦提交，则对数据库中数据的改变会是永久性的，即便数据库系统遇到故障也不会丢失。

# 2.并发读 #

如果不对事务进行隔离性的保障，则在多个事务并发进行时，可能出现：**脏读、不可重复读、幻读。**

事实上，并发事务还会带来**更新丢失问题**：当两个或多个事务选择同一行，然后基于最初的值选定该行进行更新该行时，由于事务之间没有联系，就会发生丢失更新的问题

## 2.1.脏读 ##

脏读：一个事务处理过程中，读取了另一个事务还未提交的数据。

举例：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]

1.  money = 0.
2.  事务A、B开启。
3.  事务A将money修改为100，但`还未提交`。
4.  事务B执行`money = money + 100`，将money修改为200。
5.  事务A回滚，事务B提交。
6.  异常：经过一次自增100的操作，money却增加了200，好懵！！

重点：针对`还未提交`的数据。

## 2.2.不可重复读 ##

不可重复读：一个事务处理过程中，对同一数据的多次查询得到不同的结果，这是由于另一个事务在多次查询间隔修改了这个数据。

举例：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]

1.  money = 0。
2.  事务A、B开启。
3.  事务B第一次读取money = 0。
4.  事务A修改money为100，然后`提交`。
5.  事务B第二次读取money = 100。
6.  异常：在同一个事务中，对money的两次读取，结果不同，好懵！！

重点：针对被`修改`且`已提交`的数据。

## 2.3.幻读 ##

幻读：一个事务处理过程中，读取了另一个事务新`增加`或`删除`的数据。

举例：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]

1.  表中共计10条记录。
2.  事务A、B开启。
3.  事务B第一次count，获悉count(id) = 10。
4.  事务A新增了2条记录，删除了一条记录，然后`提交`。
5.  事务B第二次count，获悉count(id) = 11。
6.  异常：在同一个事务中，对表中数据总条数的两次统计，结果不同，好懵！！

重点：针对新`增删`且`已提交`数据。

## 2.4 解决方案 ##

更新丢失可以通过加锁来解决，而“脏读”、“不可重复读”、“幻读”属于数据库一致性问题，由数据库提供一定的事务隔离机制来解决

## 2.5 事务隔离方式实现 ##

1.  在读取数据前，对其进行加锁，阻止事务对数据进行修改
2.  不用加任何锁，通过一定机制生成一个数据请求时间点的一致性数据快照，并用这个快照提供一定级别的一致性读取，这种方式也叫多版本并发控制简称MVCC或MCC

# 三、事务隔离级别 #

MySql提供了四种事务隔离级别，从低到高依次是：**读未提交、读已提交、可重复读、串行化。**

## 3.1.读未提交 Read Uncommitted ##

*  简单理解：一个事务可以读取`Read`到其他事务未提交`Uncommitted`的数据。
 *  解决的并发事务问题：最低级别，无法解决任何问题。
 *  未解决的并发事务问题：脏读、不可重复读、幻读。

## 3.2.读已提交 Read Committed ##

*  简单理解：一个事务需要读取`Read`到其他事务已经提交`Committed`的数据。
 *  解决的并发事务问题：因为`已提交`的保证，能够避免脏读的出现。
 *  未解决的并发事务问题：不可重复读、幻读。

## 3.3.可重复读Repeatable Read ##

*  简单理解：一个事务能够对同一记录进行重复性的`Repeatable`读取`Read`，多次读取结果一致。
 *  解决的并发事务问题：不可重复读、脏读。
 *  未解决的并发事务问题：幻读
 *  特别：MySql的`默认事务隔离级别`。

## 3.4.可串行化Serializable ##

*  简单理解：多个事务以串行化`Serializable`的方式运行，自然不会产生并发事务问题。
 *  解决的并发事务问题：幻读、不可重复读、脏读。
 *  特别：效率特别低。

## 3.5.三种并发读与四种事务隔离级别的总结 ##

<table> 
 <thead> 
  <tr> 
   <th>隔离级别</th> 
   <th>脏读</th> 
   <th>不可重复读</th> 
   <th>幻读</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>读未提交</td> 
   <td>未解决</td> 
   <td>未解决</td> 
   <td>未解决</td> 
  </tr> 
  <tr> 
   <td>读已提交</td> 
   <td>解决</td> 
   <td>未解决</td> 
   <td>未解决</td> 
  </tr> 
  <tr> 
   <td>可重复读</td> 
   <td>解决</td> 
   <td>解决</td> 
   <td>未解决</td> 
  </tr> 
  <tr> 
   <td>可串行化</td> 
   <td>解决</td> 
   <td>解决</td> 
   <td>解决</td> 
  </tr> 
 </tbody> 
</table>

## 3.6.隔离级别的查看与设置 ##

### 3.6.1.查看 ###

mysql> select @@tx_isolation;
    +-----------------+
    | @@tx_isolation  |
    +-----------------+
    | REPEATABLE-READ |
    +-----------------+
    1 row in set (0.03 sec)

### 3.6.2.mysql设置 ###

mysql> set tx_isolation='read-committed';
    Query OK, 0 rows affected (0.01 sec)
    
    mysql> select @@tx_isolation;
    +----------------+
    | @@tx_isolation |
    +----------------+
    | READ-COMMITTED |
    +----------------+
    1 row in set (0.01 sec)

### 3.6.3.java设置 ###

注意：在开启事务之前，设置事务隔离级别。

//获取连接
    Connection conn = getConnect();
    
    //设置事务隔离级别
    conn.setTrasactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
    
    //开启事务
    conn.setAutoCommit(false);

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]: /images/20211018/21938e21666f4460bd96c7e1b2a695b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]: /images/20211018/34a0c514cff946f69b9801bb26c923ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]: /images/20211018/2429f895afd2450784953b8507015497.png