MySQL——事务与存储过程（一）事务管理（4）事务的隔离级别

数据库是多线程并发访问的，所以很容易出现多个线程同时开启事务的情况，这样就会出现脏读、重复读以及幻读的情况，为了避免这种情况的发生，就需要为事务设置隔离级别。在 MySQL 中，事务有4种隔离级别，接下来将针对这4种隔离级别进行详细的讲解。

1、READ UNCOMMITTED

READ UNCOMMITTED(读未提交)是事务中最低的级别，该级别下的事务可以读取到另一个事务中未提交的数据，也被称为脏读(Dirty Read)，这是相当危险的。由于该级别较低，在实际开发中避免不了任何情况，所以一般很少使用。

2、READ COMMITTED

大多数的数据库管理系统的默认隔离级别都是 READCOMMITTED(读提交)(如Oracle)，该级别下的事务只能读取其他事务已经提交的内容，可以避免脏读，但不能避免重复读和幻读的情况。重复读就是在事务内重复读取了别的线程已经提交的数据，但两次读取的结果不一致，原因是查询的过程中其他事务做了更新的操作。幻读是指在一个事务内两次查询中数据条数不一致，原因是查询的过程中其他的事务做了添加操作。这两种情况并不算错误，但有些情况是不符合实际需求的，后面会具体讲解。

3、REPEATABLE READ

REPEATABLE READ(可重复读)是 MySQL默认的事务隔离级别，它可以避免肘读、不可重复读的问题，确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。但理论上，该级别会出现幻读的情况，不过 MySQL的存储引擎通过多版本并发控制机制解决了该问题，因此该级别是可以避免幻读的。

4、SERIALIZABLE

SERIALIZABLE(可串行化)是事务的最高隔离级别，它会强制对事务进行排序，使之不会发生冲突，从而解决脏读、幻读、重复读的问题。实际上，就是在每个读的数据行上加锁。这个级别，可能导致大量的超时现象和锁竞争，实际应用中很少使用。

上述的4种级别可能会产生不同的问题，如脏读、重复读、幻读、耗时的操作等，接下来就分别演示这几种情况，具体如下。

1、脏读

所谓的脏读就是指一个事务读取了另外一个事务未提交的数据。试想一下，a账户要给b账户转账 100 元购买商品，如果a账户开启了一个事务，执行了下面的 UPDATE语句做了转账的工作。

UPDATE account SET money=money-100 WHERE name='a';
UPDATE account SET money=money+100 WHERE name='b';

如果a账户先不提交事务，通知b账户来查询，由于b的隔离级别较低，此时就会读到a事务中未提交的数据，发现a确实给自己转了 100元，然后给a发货，等b发货成功后a就将事务回滚，此时，b就会受到损失，这就是脏读造成的。

为了演示上述情况，首先需要开启两个命令行窗口(相当于开启两个线程)，分别模拟a账户和b账户，然后登录到 MySQL数据库，并将操作的数据库切换为 chaptero6，如下两张图所示。

需要注意的是，下面所有的操作都是在这两个窗口中进行的，为了方便査看代码，将这两个窗口中的操作代码直接复制出来。

1）设置b账户中事务的隔离级别

大家都知道 MySQL的默认隔离级别是 REPEATABLE READ(可重复读)，该级别是可以避免脏读的，因此需要将b账户中事务的隔离级别设置为 READ UNCOMMITTED(读未提交)，具体语句如下：

mysql> SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
Query OK, 0 rows affected (0.00 sec)

上述语句中，SESSION 表示当前会话，TRANSACTION 就表示事务，ISOLATION表示隔离，LEVEL表示级别，READ UNCOMMITTED 表示当前的隔离级别，该语句执行成功后，使用 SELECT语句查询事务的隔离级别，结果如下：

mysql> SELECT @@transaction_isolation;
+-------------------------+
| @@transaction_isolation |
+-------------------------+
| READ-UNCOMMITTED        |
+-------------------------+
1 row in set (0.00 sec)

从上述结果可以看出，b账户事务的隔离级别已经被修改为READ UNCOMMITTED，来就可以演示脏读的情况。

2)演示脏读

b账户：为了证明出现脏读的情况，首先在b账户中开启一个事务，并在该事务中查当前账户的余额信息，查询结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

a 账户：在a账户中开启一个事务，并在当前窗口中执行转账功能，具体语句如下：

START TRANSACTION;
UPDATE account SET money=money-100 WHERE name='a';
UPDATE account SET money=money+100 WHERE name='b';

需要注意的是，此时不要提交事务，如果提交事务就无法演示出现脏读的情况。

b账户：a账户执行完转账语句后，b账户查询当前账户，此时的查询结果如下。

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1100 |
+----+------+-------+
2 rows in set (0.00 sec)

从查询结果可以看出，a账户已经成功给b账户转账了 100元钱，这是由于b账户的事务隔离级别较低，因此读取了a账户中还没有提交的内容，出现了脏读的情况，这时b误以为a账户已经转账成功了，便会给a发货，当b发货后a如果不提交事务将事务回滚，此时b就会受到损失。上述情况演示完，最后还需将a账户中的事务回滚，将b账户中的事务提交。

3)设置b账户中事务的隔离级别

为了防止脏读发生，可以将b账户中事务的隔离级别设置为 READ COMMITED(读提交)，该级别可以避免脏读，具体语句如下：

SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

上述语句执行成功后，b账户的隔离级别已经被设置为 READ COMMITTED。

4)验证是否出现脏读

b账户：为了说明没有出现脏读的情况，首先要在b账户中开启一个事务，并在该事务中查询各账户的余额信息，查询结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.01 sec)

a账户：在a账户中重新开启一个事务，实现转账功能，具体语句如下：

START TRANSACTION;
UPDATE account SET money=money-100 WHERE name='a';
UPDATE account SET money=money+100 WHERE name='b';

b账户：当a账户转账成功后，可以在b账户中再次查询各账户的余额信息，查询结果如下：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.01 sec)

通过对比两次查询结果可以发现，b账户在同一个事务中的查询结果是一致的，并没有查询到a账户中未提交的内容，因此可以说明 READ COMMITTED 隔离级别可以避免脏读。最后分别将a账户中的事务和b账户中的事务回滚。

2.不可重复读

所谓的不可重复读(NON-REPEATABLE READ)是指事务中两次查询的结果不义，原因是在查询的过程中其他事务做了更新的操作。例如，银行在做统计报表时，第一次查询a账户有 1000 元钱，第二次查询a账户有 900 元钱，原因是统计期间a账户取出1100元，这样就会导致多次统计报表的结果不一致。

不可重复读和脏读有点类似，但是胜读是读取前一个事务未提交的胜数据，不可重该是在事务内重复读取了别的线程已提交的数据，对于初学者来说可能比较难以理接下来就通过案例来演示不可重复读的情况，具体步骤如下。

1)演示不可重复读

b账户：首先在b账户中开启一个事务，然后在当前事务中查询各账户的余额信息查询结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.01 sec)

a账户：在a账户中不用开启事务，直接使用 UPDATE 语句执行更新操作即可，具体语句如下：

UPDATE account SET money=money-100 WHERE name='a';

由于a账户只需要执行修改的操作，不需要保证同步性，因此直接执行 SQL 语句就可以，执行结果如下所示：

mysql> UPDATE account SET money=money-100 WHERE name='a';
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

使用 SELECT 语句查询a账户的余额信息，查询结果如下：

mysql> select * from account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

b账户：当a账户中的更新操作执行成功后，在b账户中再次查询各账户的余额，查询结果如下：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

对比b账户两次查询结果可以发现，两次查询结果是不一致的，实际上这种操作是没错的，但是如果在银行统计报表时，这种情况是不符合需求的，因为我们并不希望在一个事务中看到的查询结果不一致，这就是不可重复读。上述情况演示成功后，还是要将 b账户中的事务提交。

2)设置b账户中事务的隔离级别

b账户：为了防止重复读的情况出现，可以将该事务的隔离级别设置为 REPEATABLEREAD(可重复读)，具体语句如下：

SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

上述语句执行成功后，b账户事务的隔离级别被设置为 REPEATABLE READ。

3)验证是否出现不可重复读

b账户：在b账户中，重新开启一个事务，然后使用 SELECT 语句查询当前账户的余额，查询结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.01 sec)

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

a账户：在a账户中不开启事务，直接使用 UPDATE语句执行更新操作，具体如下：

UPDATE account SET money=money-100 WHERE name='a';

使用 SELECT 语句查询各账户的余额信息，查询结果如下：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

b账户：当a账户中的 UPDATE语句执行成功后，b账户在当前事务中，再次查询各账户的余额信息，查询结果如下：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

3、幻读

幻读(PHANTOM READ)又被称为虚读，是指在一个事务内两次查询中数据条数不一致，幻读和不可重复读有些类似，同样是在两次查询过程中，不同的是，幻读是由于其他事务做了插入记录的操作，导致记录数有所增加。

例如，银行在做统计报表时统计 account表中所有用户的总额时，此时总共有三个账户总共金额有 3000，这时新增了一个账户，并且存人了1000元，这时银行再统计时发现账户的总金额变为 4000，造成了幻读的情况。接下来就通过案例来演示幻读的情况，具体步骤如下。

1)设置b账户的隔离级别

b账户：由于前面将事务的隔离级别设置为 REPEATABLE READ(可重复读)，这种隔离级别可以避免幻读的出现，因此需要将事务的隔离级别设置得更低，下面将事务的隔离级别设置为 READ COMMITTED，具体语句如下：

SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;

上述语句执行成功后，b账户事务的隔离级别为 READ COMMITTED。

2)演示幻读

b账户：首先在b账户中开启一个事务，然后在当前事务中查询账户的余额信息，查询结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

a账户：在对a账户进行添加操作之前，使用 SELECT 语句查看当前a账户中的信息，执行语句如下所示：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

接下来对a账户进行添加操作，a账户不用开启事务，直接执行添加操作即可，具体语句如下：

INSERT INTO account(name, money) VALUES('c',1000);

b账户：当a账户添加记录成功后，可以在b账户中再次查询账户的余额信息，查询结果如下：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
|  3 | c    |  1000 |
+----+------+-------+
3 rows in set (0.00 sec)

通过对比b账户设置 READ COMMITTED 隔离级别前后，发现第二次查询数据时3 rows in set (0.00 sec)第一次査询时多了一条记录，这种情况并不是错误的，但可能不符合实际需求。需要注意的是，上述情况演示完成后，将b账户中的事务提交。

3)重新设置b账户的隔离级别

b账户：为了防止出现幻读，可以将b账户的隔离级别设置为REPEATABIREAD，具体语句如下：

SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

上述语句执行成功后，事务的隔离级别被设置为 REPEATABLE READ。

4)验证是否出现幻读

b账户：在b账户中重新开启一个事务，并在该事务中查询当前账户的余额信息，询结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.01 sec)

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
|  3 | c    |  1000 |
+----+------+-------+
3 rows in set (0.01 sec)

a账户：在对a账户进行添加操作之前，使用 SELECT 语句查看当前a账户中的信息，执行语句如下所示：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
|  3 | c    |  1000 |
+----+------+-------+
3 rows in set (0.01 sec)

接下来对a账户进行添加操作，在a账户中不开启事务，直接执行添加操作，具体语句如下：

INSERT INTO account(name, money) VALUES('d',1000);

b账户：当a账户的添加操作执行成功后，再次查询当前账户的余额信息，查询结果如下：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
|  3 | c    |  1000 |
+----+------+-------+
3 rows in set (0.00 sec)

对比b账户的两次查询结果可以看出，在同一个事务中两次的查询结果是一致的并没有出现重复读取的情况，因此可以说明当前事务的隔离级别可以避免幻读，最后还需要使用 COMMIT 语句提交当前事务，提交后的账户查询结果如下所示：

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
|  3 | c    |  1000 |
|  4 | d    |  1000 |
+----+------+-------+
4 rows in set (0.00 sec)

4、可串行化

可串行化(SERIALIZABLE)是事务的最高隔离级别，它在每个读的数据行上加上锁，使之不可能相互冲突，因此会导致大量的超时现象，接下来通过具体的案例来演示，具体步骤如下：

1)设置b账户中事务的隔离级别

b账户：首先将b账户的隔离级别设置为 SERIALIZABLE，具体语句如下：

SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

上述语句执行成功后，当前事务的隔离级别被成功设置为 SERIALIZABLE。

2)演示可串行化器声息

b账户：首先在b账户中开启事务，然后使用 SELECT语句查询各个账户的余额信息，查询结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> SELECT * FROM account;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   800 |
|  2 | b    |  1000 |
|  3 | c    |  1000 |
|  4 | d    |  1000 |
+----+------+-------+
4 rows in set (0.00 sec)

a账户：开启一个事务，并在该事务中执行插入操作，执行结果如下：

mysql> START TRANSACTION;
Query OK, 0 rows affected (0.00 sec)

mysql> INSERT INTO account(name,money)VALUES('e',1000);
Query OK, 1 row affected (0.00 sec)

从上述执行结果可以看出，当b账户正在事务中查询余额信息时，a账户中的操作是不能立即执行的。

3)提交事务

b账户：当b账户查询完余额信息后，立即提交当前事务，具体语句如下：

COMMIT;

a账户：当b账户中的事务提交成功后，a账户中的添加操作才能执行成功，并输出如下语句：

Query OK, 1 row affected(0.00 sec)

从上述情况可以说明，如果一个事务使用了 SERIALIZABLE(可串行化)隔离级别时，在这个事务没有被提交前，其他的线程只能等到当前操作完成后，才能进行操作，这样会非常耗时，而且会影响数据库的性能，通常情况下是不会使用这种隔离级别的。