---
[TOC]
---
# MySQL事务
## ACID
1.**原子性(Atomcity)**
一个事务的最小单元,要么全部成功要么全部失败,执行的过程中是不能被打断或者执行其他操作的。
2.**一致性(Consistent)**
事务开始前和结束后,数据库的完整性约束没有被破坏。比如A向B转账,不可能A扣了钱,B却没收到,事务开始前A+B=500,事务结束后A+B不可能!=500。
3.**隔离性(Isolation)**
隔离性表示各个事务之间不会互相影响,数据库一般会提供多种级别的隔离。实际上多个事务是并发执行的,但是他们之间不会互相影响。
4.**持久性(Durability)**
事务提交后,事务对数据库的所有更新将被保存到数据库,不能回滚。
##事务的隔离级别
事务分为以下4个级别
- **Read UnCommitted(可以读取未提交数据)**
- **Read Committed(只能读到已提交数据)**
- **Read Repeatable(一个事务中重复读取,数据保持一致性)**
- **Serializable(串行执行,不会造成不一致问题,但会影响并发)**
##不同的隔离级别可能引发不同的一致性问题
|隔离级别|脏读|不可重复读|幻读|
|:-:|:-:|:-:|:-:|
|Read UnCommitted|Y|Y|Y|
|Read Committed|N|Y|Y|
|Read Repeatable|N|N|Y|
|serializable|N|N|N|
##并发事务下可能导致的数据不一致
### 1. **脏读(Dirty Read)> 读取到中间值**
事务A开启事务,做更新操作数据由<font color="#FFA500">300</font>更新为<font color="#9ACD32">400</font>,并未commit,此时事务B会读取到A更新但未提交的值<font color="#9ACD32">400</font>。此时A事务 rollback,但是B事务已经读取到A更新的值,造成<font color="#CD0000">**脏读**</font>。
事例:
- **A连接**
```mysql
#设置当前会话事务隔离级别为读未提交
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
#开始执行事务
START TRANSACTION;
SELECT user_id,balance FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 300 |
+---------+---------+
#②在事务B第一次查询之后进行更新操作
UPDATE tb_user_account SET balance = 400 WHERE user_id = 86;
#④发生异常进行回滚
ROLLBACK;
```
- **B连接**
```mysql
#查询当前连接事务级别
SELECT @@tx_isolation;
#设置当前会话事务隔离级别为读未提交
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
#开始执行事务
START TRANSACTION;
#①在事务A更新之前执行
SELECT * FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 300 |
+---------+---------+
#③在事务A更新之后执行,此时读取到了未提交的数据400
SELECT user_id,balance FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 400 |
+---------+---------+
#⑤在事务A回滚之后执行,两次读取到的数据不一致,发生的了脏读
SELECT user_id,balance FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 300 |
+---------+---------+
```
```flow
A=>operation: 事务A 更新为400
BS1=>operation: 事务B 第一次查询到300
BS2=>operation: 事务B 第二次查询到400(中间值)脏读
ROLL=>operation: 事务A 回滚
BS3=>operation: 事务B 第三次查询到300 (数据不一致)
BS1->A->BS2->ROLL->BS3
```
### 2. **不可重复读(UnRepeatable Read)> 更新场景,数据不一致**
事务A开启事务,做更新操作数据由<font color="#FFA500">300</font>更新为<font color="#9ACD32">400</font>,并未commit,此时事务B查询值为<font color="#FFA500">300</font>,解决了脏读问题。此时A提交事务,事务B再次查询值为<font color="#9ACD32">400</font>,两次查询数据不一致。(<font color="#CD0000">**不可重复读**</font>)
事例:
- **A连接**
```mysql
#设置当前会话事务隔离级别为读已提交
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
#开始执行事务
START TRANSACTION;
SELECT user_id,balance FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 300 |
+---------+---------+
#②在事务B第一次查询之后进行更新操作
UPDATE tb_user_account SET balance = 400 WHERE user_id = 86;
#④提交数据
COMMIT;
```
- **B连接**
```mysql
#查询当前连接事务级别
SELECT @@tx_isolation;
#设置当前会话事务隔离级别为读未提交
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
#开始执行事务
START TRANSACTION;
#①在事务A提交之前执行
SELECT * FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 300 |
+---------+---------+
#③在事务A提交之后执行,此时读取到的值还是300,解决了脏读问题。
SELECT user_id,balance FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 300 |
+---------+---------+
#⑤在事务A提交之后执行,两次读取到的数据不一致,发生的了不可重复读。
SELECT user_id,balance FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 400 |
+---------+---------+
```
```flow
A=>operation: 事务A 更新为400
BS1=>operation: 事务B 第一次查询到300
BS2=>operation: 事务B 第二次查询到300,保证了不发生脏读
ROLL=>operation: 事务A 提交
BS3=>operation: 事务B 第三次查询到400 (不可重复读,数据不一致)
BS1->A->BS2->ROLL->BS3
```
### 3. **幻读(Phantom Read)>插入or删除场景,数据不一致**
事务A开启事务,做查询大于<font color="#FFA500">0</font>的数据,并未commit,此时B连接插入一条大于0的数据。A再次查询大于<font color="#FFA500">0</font>的数据,但是并查询到B插入的数据,造成(<font color="#CD0000">**幻读**</font>)。
事例:
- **A连接**
```mysql
#设置当前会话事务隔离级别为可重复读
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;
#开始执行事务
START TRANSACTION;
#①查询大于0的数据
SELECT count(1) FROM tb_user_account WHERE balance > 0;
+----------+
| count(1) |
+----------+
| 1 |
+----------+
#③查询大于0的数据,查到新增数据(造成幻读,BUT MySQL,MVVC解决了此问题)
SELECT count(1) FROM tb_user_account WHERE balance > 0;
+----------+
| count(1) |
+----------+
| 2 |
+----------+
```
- **B连接**
```mysql
#②在事务A提交之前执行
INSERT INTO tb_user_account(balance) VALUES(100);
```
```flow
A=>operation: 事务A 查询大于0的数据
BS1=>operation: 事务B 插入一条大于0的数据
AS2=>operation: 事务A 查询大于0的数据,查到了新增数据。(幻读,数据不一致)
A->BS1->ROLL->BS3
```
### 4. 更新丢失(lost update)>幻读中数据更新丢失
使用 READ COMMITTED隔离级别,事务A开启事务,做更新操作数据增加<font color="#FFA500">100</font>,并未commit,此时事务B也做更新操作数据增加<font color="#9ACD32">100</font>。此时B先提交事务,之后A再提交事务,会造成B事务**<font color="#CD0000">更新丢失</font>**。(MySQL的InnoDB使用了MVCC,在提交B时会锁住行数据,避免此种问题)。
事例:
- **A连接**
```mysql
#设置当前会话事务隔离级别为读已提交
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
#开始执行事务
START TRANSACTION;
SELECT user_id,balance FROM tb_user_account;
+---------+---------+
| user_id | balance |
+---------+---------+
| 80 | 0 |
| 86 | 300 |
+---------+---------+
#①更新操作数据增加100。
UPDATE tb_user_account SET balance = balance + 100 WHERE user_id = 86;
#④提交数据,此时会造成事务B的更新丢失。
COMMIT;
```
- **B连接**
```mysql
#查询当前连接事务级别
SELECT @@tx_isolation;
#设置当前会话事务隔离级别为读未提交
SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
#开始执行事务
START TRANSACTION;
#②在事务A提交之前执行,增加100。
UPDATE tb_user_account SET balance = balance + 100 WHERE user_id = 86;
#③事务B提交更新
COMMIT;
```
```flow
A=>operation: 事务A 增加100
BS1=>operation: 事务B 增加100
BCOMMIT=>operation: 事务B 提交
ACOMMIT=>operation: 事务A 提交(A未读取到B的更新,造成更新丢失)
A->BS1->BCOMMIT->ACOMMIT
```