# MySQL-事务介绍

---

[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

```