MySQL：事务隔离级别和一致性

一、如何理解隔离性

MySQL服务可能会同时被多个客户端进程(线程)访问，访问的方式以事务方式进行

一个事务可能由多条SQL构成，也就意味着，任何一个事务，都有执行前，执行中，执行后的阶段。而所谓的原子性，其实就是让用户层，要么看到执行前，要么看到执行后。执行中出现问题，可以随时回滚。所以单个事务，对用户表现出来的特性，就是原子性。

但，毕竟所有事务都要有个执行过程，那么在多个事务各自执行多个SQL的时候，就还是有可能会出现互相影响的情况。比如：多个事务同时访问同一张表，甚至同一行数据。就如同你妈妈给你说：你要么别学，要学就学到最好。至于你怎么学，中间有什么困难，你妈妈不关心。那么你的学习，对你妈妈来讲，就是原子的。那么你学习过程中，很容易受别人干扰，此时，就需要将你的学习隔离开，保证你的学习环境是健康的。

数据库中，为了保证事务执行过程中尽量不受干扰，就有了一个重要特征：隔离性

数据库中，允许事务受不同程度的干扰，就有了一种重要特征：隔离级别

二、隔离性的体现

讲个小故事，如果同一时间有一个update操作和一个select操作，那么哪一个先执行呢？？如果是update先执行，那么select拿到的就是最新的数据，而如果是select先执行，那么拿到的是老的数据，大多数人肯定会觉得肯定要让update先执行而看到新数据，但实际上这种想法是不太合理的。比方拿时间线来说，我们的父母出生得比我们早，那么直到他们生下我的这段时间里，我是看不到这个世界的，我只看得到自己出生之后所在时间线的世界，而以前已经过世的亲人也看不到我现在所看到的世界...... 这就说明了我们站在上帝视角，每一个人都只能看到自己活着时候世界所对应的样子，所以我们时间线一直在延展的时候，每个人看到的世界都应该是不一样的，这才符合自然规律,人与人之间具有隔离性，因此让每一个事务都看到最新的数据是不合理的，而是应该让每一个事务在他到来时看到他应该看到的数据。这就是隔离性的体现。（所以updata和select谁先跑取决于谁先来）

可是先到来的并不一定先退出，所以即使我先到来了但是操作时间很长，你在我操作结束之前也是看不到我更新后的数据的，这也是隔离性的体现。举个例子，你的朋友要转账100给你，在你朋友给你转钱的时候，你一定是得等他转钱事务都完成了才能查到。这是正常的隔离性。但是隔离性具体要隔离到什么程度，我们就有了隔离级别的概念！（比方说我们去服装店，如果是换裤子，我们会进试衣间，如果是换上衣，我们会根据情况，如果是换鞋子，那直接在外面换就可以了，所以这就是因为影响不同而导致隔离级别的不同）

三、隔离级别（读写并发）

1、读未提交【Read Uncommitted】：在该隔离级别，所有的事务都可以看到其他事务没有提交的执行结果。 （实际生产中不可能使用这种隔离级别的），但是相当于没有任何隔离性，也会有很多并发问题，如脏读，幻读，不可重复读等，我们上面为了做实验方便，用的就是这个隔离性。

2、读提交【Read Committed】：**该隔离级别是大多数数据库的默认的隔离级别（不是 MySQL 默认的）。它满足了隔离的简单定义:一个事务只能看到其他的已经提交的事务所做的改变。（**就是你提交了我还没退出就能看到）这种隔离级别会引起不可重复读，即一个事务执行时，如果多次 select，可能得到不同的结果。

3、可重复读【Repeatable Read】：这是 MySQL 默认的隔离级别，它确保同一个事务，在执行中，多次读取操作数据时，会看到同样的数据行。(就是你提交了，并且我结束了，才能看到 ) 但是会有幻读问题。

4、串行化【Serializable】: 这是事务的最高隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决了幻读的问题。（就是你结束了我才能执行，保证数据绝对安全）它在每个读的数据行上面加上共享锁。但是可能会导致超时和锁竞争（这种隔离级别太极端，实际生产基本不使用）

**隔离级别如何实现：隔离，基本都是通过锁实现的，不同的隔离级别，锁的使用是不同的。**常见有，表锁，行锁，读锁，写锁，间隙锁(GAP),Next-Key锁(GAP+行锁)等。不过，我们目前现有这个认识就行，先关注上层使用。

上面四种隔离级别关注的场景都是当有一个人在进行写的时候另一个人来读 （读写并发）

四、查看与设置隔离性

sql 复制代码

-- 查看 
mysql> SELECT @@global.tx_isolation; --查看全局隔级别 
+-----------------------+ 
| @@global.tx_isolation | 
+-----------------------+ 
| REPEATABLE-READ       | 
+-----------------------+ 
1 row in set, 1 warning (0.00 sec) 
 
mysql> SELECT @@session.tx_isolation; --查看会话(当前)全局隔级别（默认用全局的初始化）
+------------------------+ 
| @@session.tx_isolation | 
+------------------------+ 
| REPEATABLE-READ        | 
+------------------------+ 
1 row in set, 1 warning (0.00 sec) 
 
mysql> SELECT @@tx_isolation; --默认同上 
+-----------------+ 
| @@tx_isolation  | 
+-----------------+ 
| REPEATABLE-READ |
+-----------------+ 
1 row in set, 1 warning (0.00 sec) 
 
--设置 
-- 设置当前会话 or 全局隔离级别语法 
SET [SESSION | GLOBAL] TRANSACTION ISOLATION LEVEL 
{READ UNCOMMITTED | READ COMMITTED | 
REPEATABLE READ | SERIALIZABLE} 
 
--设置当前会话隔离性，另起一个会话，看不多，只影响当前会话 
mysql> set session transaction isolation level serializable; -- 串行化 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> SELECT @@global.tx_isolation; --全局隔离性还是RR 
+-----------------------+ 
| @@global.tx_isolation | 
+-----------------------+ 
| REPEATABLE-READ       | 
+-----------------------+ 
1 row in set, 1 warning (0.00 sec) 
 
mysql> SELECT @@session.tx_isolation; --会话隔离性成为串行化 
+------------------------+ 
| @@session.tx_isolation | 
+------------------------+ 
| SERIALIZABLE           | 
+------------------------+ 
1 row in set, 1 warning (0.00 sec) 
 
mysql> SELECT @@tx_isolation; --同上 
+----------------+ 
| @@tx_isolation | 
+----------------+ 
| SERIALIZABLE   | 
+----------------+ 
1 row in set, 1 warning (0.00 sec) 
 
 
--设置全局隔离性，另起一个会话，会被影响 
mysql> set global transaction isolation level READ UNCOMMITTED; 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> SELECT @@global.tx_isolation; 
+-----------------------+ 
| @@global.tx_isolation | 
+-----------------------+ 
| READ-UNCOMMITTED      | 
+-----------------------+ 
1 row in set, 1 warning (0.00 sec) 
 
mysql> SELECT @@session.tx_isolation; 
+------------------------+ 
| @@session.tx_isolation | 
+------------------------+
| READ-UNCOMMITTED       | 
+------------------------+ 
1 row in set, 1 warning (0.00 sec)
 
mysql> SELECT @@tx_isolation; 
+------------------+ 
| @@tx_isolation   | 
+------------------+ 
| READ-UNCOMMITTED | 
+------------------+ 
1 row in set, 1 warning (0.00 sec)
 -- 注意，如果没有现象，关闭mysql客户端，重新连接。

五、读未提交【Read Uncommitted】

--几乎没有加锁，虽然效率高，但是问题太多，严重不建议采用

sql 复制代码

--终端A 
-- 设置隔离级别为 读未提交 
mysql> set global transaction isolation level read uncommitted; 
Query OK, 0 rows affected (0.00 sec) 

--重启客户端
mysql> select @@tx_isolation;
+------------------+
| @@tx_isolation   | 
+------------------+ 
| READ-UNCOMMITTED | 
+------------------+ 
1 row in set, 1 warning (0.00 sec)

mysql> select * from account;
+----+--------+----------+
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 100.00   | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 

mysql> begin;                   --开启事务 
Query OK, 0 rows affected (0.00 sec)
 
mysql> update account set blance=123.0 where id=1;  --更新指定行 
Query OK, 1 row affected (0.05 sec) 
Rows matched: 1  Changed: 1  Warnings: 0

--没有commit哦！！！

--终端B mysql> begin;
mysql> select * from account;
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1 | 张三    | 123.00   | --读到终端A更新但是未commit的数据[insert，delete同样] 
| 2 | 李四    | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec)

一个事务在执行中，读到另一个执行中事务的更新(或其他操作)但是未commit的数据，这种现象叫做脏读(dirty read)

六、读提交（不可重复读）【Read Committed】

sql 复制代码

-- 终端A 
mysql> set global transaction isolation level read committed; 
Query OK, 0 rows affected (0.00 sec) 
--重启客户端 
mysql> select * from account; --查看当前数据 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 123.00   | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 
 
mysql> begin; --手动开启事务，同步的开始终端B事务 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> update account set blance=321.0 where id=1; --更新张三数据 
Query OK, 1 row affected (0.00 sec) 
Rows matched: 1 Changed: 1 Warnings: 0 
 
--切换终端到终端B，查看数据。 
 
mysql> commit; --commit提交！ 
Query OK, 0 rows affected (0.01 sec) 
 
--切换终端到终端B，再次查看数据。 
 
--终端B 
mysql> begin; --手动开启事务，和终端A一前一后 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> select * from account; --终端A commit之前，查看不到 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 123.00   | --老的值 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 
 
--终端A commit之后，看到了！
--but，此时还在当前事务中，并未commit，那么就造成了，同一个事务内，同样的读取，在不同的时间段(依旧还在事务操作中！)，读取到了不同的值，这种现象叫做不可重复读(non reapeatable read)！！（这个是问题吗？？） 
mysql> select *from account; 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 321.00   |  --新的值 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec)

问题：不可重复读是问题吗？？会造成什么后果？？

比方说小王要负责给tom把工资从3200改成4500.而小张要负责根据工资表筛选奖品发放名单，在读提交的情景下，当小张运行到中间的时候突然小王把修改的信息提交了，这个时候小张就有可能在员工表里看到两个tom，这就会造成工作上的失误！！

所以我们不应该让我们的用户在实际操作的时候，两个正在执行的事物一方能够读到另一方的提交。所以虽然读提交比读未提交隔离级别高，但是我们也不推荐！！因为会导致上述的不可重复读的问题！！

七、可重复读【Repeatable Read】

sql 复制代码

mysql> select * from account; --终端A中事务 commit之前，查看当前表中数据，数据未更新 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 321.00   | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 
 
mysql> select * from account; --终端A中事务 commit 之后，查看当前表中数据，数据未更新 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 321.00   | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 
 
--可以看到，在终端B中，事务无论什么时候进行查找，看到的结果都是一致的，这叫做可重复读！ 
 
mysql> commit; --结束事务 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> select * from account; --再次查看，看到最新的更新数据 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec)

--如果将上面的终端A中的update操作，改成insert操作，会有什么问题？？

sql 复制代码

--终端A 
mysql> select *from account; 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 321.00   | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 
 
mysql> begin; --开启事务，终端B同步开启 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> insert into account (id,name,blance) values(3, '王五', 5432.0); 
Query OK, 1 row affected (0.00 sec) 
 
--切换到终端B，查看另一个事务是否能看到
mysql> commit; --提交事务 
Query OK, 0 rows affected (0.00 sec) 
 
--切换终端到终端B，查看数据。 
 
mysql> select * from account; 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
| 3  | 王五   | 5432.00  | 
+----+--------+----------+ 
3 rows in set (0.00 sec) 
 
--终端B 
mysql> begin; --开启事务 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> select * from account; --终端A commit前 查看 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 
 
mysql> select * from account; --终端A commit后 查看 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec)

--多次查看，发现终端A在对应事务中insert的数据，在终端B的事务周期中，也没有什么影响，也符合可重复的特点。**但是，一般的数据库在可重复读情况的时候，无法屏蔽其他事务insert的数据(为什么？因为隔离性实现是对数据加锁完成的，而insert待插入的数据因为并不存在，那么一般加锁无法屏蔽这类问题),会造成虽然大部分内容是可重复读的，但是insert的数据在可重复读情况被读取出来，导致多次查找时，会多查找出来新的记录，就如同产生了幻觉。这种现象，叫做幻读(phantom read)。**很明显，MySQL在RR级别的时候，是解决了幻读问题的(解决的方式是用Next-Key锁(GAP+行锁)解决的。这块比较难，可了解一下)。

sql 复制代码

mysql> select * from account; 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
+----+--------+----------+ 
2 rows in set (0.00 sec) 
 
mysql> commit; --结束事务 
Query OK, 0 rows affected (0.00 sec)
mysql> select * from account; --看到更新 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
| 3  | 王五   | 5432.00  | 
+----+--------+----------+ 
3 rows in set (0.00 sec)

八、串行化【serializable】

--对所有操作全部加锁，进行串行化，不会有问题，但是只要串行化，效率很低，几乎完全不会被采用

sql 复制代码

--终端A 
mysql> set global transaction isolation level serializable; 
Query OK, 0 rows affected (0.00 sec) 
mysql> select @@tx_isolation; 
+----------------+ 
| @@tx_isolation | 
+----------------+ 
| SERIALIZABLE   | 
+----------------+ 
1 row in set, 1 warning (0.00 sec) 
mysql> begin; --开启事务，终端B同步开启 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> select * from account; --两个读取不会串行化，共享锁 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
| 3  | 王五   | 5432.00  | 
+----+--------+----------+ 
3 rows in set (0.00 sec) 
 
mysql> update account set blance=1.00 where id=1; --终端A中有更新或者其他操作，会阻塞。直到终端B事务
提交。 
Query OK, 1 row affected (18.19 sec) 
Rows matched: 1 Changed: 1 Warnings: 0 
 
--终端B 
mysql> begin; 
Query OK, 0 rows affected (0.00 sec) 
 
mysql> select * from account; --两个读取不会串行化 
+----+--------+----------+ 
| id | name   | blance   | 
+----+--------+----------+ 
| 1  | 张三   | 4321.00  | 
| 2  | 李四   | 10000.00 | 
| 3  | 王五   | 5432.00  | 
+----+--------+----------+ 
3 rows in set (0.00 sec) 
 
mysql> commit; --提交之后，终端A中的update才会提交。 
Query OK, 0 rows affected (0.00 sec)

九、总结

其中隔离级别越严格，安全性越高，但数据库的并发性能也就越低，往往需要在两者之间找一个平衡点。（这个平衡点不是mysql决定而是由场景和需求决定的，所以mysql不是为我们指定隔离方式，而是给我们不同的隔离方案让我们用户根据实际场景需求做选择）

脏读(dirty read) 的重点是CUD ：一个事务在执行中，读到另一个执行中事务的更新(或其他操作)但是未commit的数据

不可重复读的重点是U和D：同样的条件, 你读取过的数据,再次读取出来发现值不一样了

幻读的重点在于C：同样的条件, 第1次和第2次读出来的记录数不一样

说明： mysql 默认的隔离级别是可重复读,一般情况下不要修改

上面的例子可以看出，事务也有长短事务这样的概念。事务间互相影响，指的是事务在并行执行的时候，即都没有commit的时候，影响会比较大

十、一致性(Consistency)

事务执行的结果，必须使数据库从一个一致性状态，变到另一个一致性状态。当数据库只包含事务成功提交的结果时，数据库处于一致性状态。**如果系统运行发生中断，某个事务尚未完成而被迫中断，而改未完成的事务对数据库所做的修改已被写入数据库，此时数据库就处于一种不正确（不一致）的状态。**因此一致性是通过原子性来保证的。

其实一致性并非技术层面的概念，而是和用户的业务逻辑强相关，一般MySQL提供技术支持，但是一致性还是要用户业务逻辑做支撑，也就是，一致性，是由用户决定的。（举个例子，比方说有个菜鸟程序员，对转账操作只在原账户减了钱，但是没有在新账户加钱所以你用户至少得保证你写的mysql语句是对的、是完整的、业务逻辑是对的！！！你能做到这些，那我就能保证你有一致性。但是你要是本身就有问题，我mysql又不了解业务，出错了关我什么事呢？所以一致性应该由mysql和程序员共同完成，这才是对一致性正确的理解）

而技术上，通过A（原子性）I（隔离性）D（持久性）保证C（一致性），前者是因，后者是果

十一、推荐阅读

如何实现事务的隔离性

Innodb中的事务隔离级别和锁的关系

Mysql 间隙锁原理，以及Repeatable Read隔离级别下可以防止幻读原理(百度)