MySQL InnoDB事务隔离级别脏读、可重复读、幻读
MySQL InnoDB事务的隔离级别有四级，默认是“可重复读”（REPEATABLE READ）。
· 未提交读（READUNCOMMITTED）。另一个事务修改了数据，但尚未提交，而本事务中的SELECT会读到这些未被提交的数据（脏读）。
· 提交读（READCOMMITTED）。本事务读取到的是最新的数据（其他事务提交后的）。问题是，在同一个事务里，前后两次相同的SELECT会读到不同的结果（不重复读）。
· 可重复读（REPEATABLEREAD）。在同一个事务里，SELECT的结果是事务开始时时间点的状态，因此，同样的SELECT操作读到的结果会是一致的。但是，会有幻读现象（稍后解释）。
· 串行化（SERIALIZABLE）。读操作会隐式获取共享锁，可以保证不同事务间的互斥。
四个级别逐渐增强，每个级别解决一个问题。
· 脏读，最容易理解。另一个事务修改了数据，但尚未提交，而本事务中的SELECT会读到这些未被提交的数据。
· 不重复读。解决了脏读后，会遇到，同一个事务执行过程中，另外一个事务提交了新数据，因此本事务先后两次读到的数据结果会不一致。
· 幻读。解决了不重复读，保证了同一个事务里，查询的结果都是事务开始时的状态（一致性）。但是，如果另一个事务同时提交了新数据，本事务再更新时，就会“惊奇的”发现了这些新数据，貌似之前读到的数据是“鬼影”一样的幻觉。
CREATETABLE `t` (
`a` int(11) NOT NULL PRIMARY KEY
) ENGINE=InnoDBDEFAULT CHARSET=utf8;
insertINTO t(a)values(1),(2),(3);
上面的文字，读起来并不是那么容易让人理解，以下用几个实验对InnoDB的四个事务隔离级别做详细的解释，希望通过实验来加深大家对InnoDB的事务隔离级别理解。
实验一：解释脏读、可重复读问题
| 更新事务 |
事务A READ-UNCOMMITTED |
事务B READ-COMMITTED, |
事务C-1 REPEATABLE-READ |
事务C-2 REPEATABLE-READ |
事务D SERIALIZABLE |
| set autocommit =0; |
? |
? |
? |
? |
? |
| start transaction ; |
? |
? |
? |
start transaction; |
? |
| insert into t(a)values(4); |
? |
? |
? |
? |
? |
| ? |
? select * from t; 1,2,3,4(脏读：读取到了未提交的事务中的数据) |
? select * from t; 1,2,3（解决脏读） |
select * from t; 1,2,3 |
? select * from t; 1,2,3 |
select * from t; 1,2,3 |
| ? |
? |
? |
? |
? |
? |
| ? |
? |
? |
? |
? |
? |
| commit; |
? |
? |
? |
? |
? |
| ? |
select * from t: 1,2,3,4 |
select * from t: 1,2,3,4 |
select * from t: 1,2,3,4 (与上面的不在一个事务中，所以读到为事务提交后最新的，所以可读到4) |
select * from t: 1,2,3（重复读：由于与上面的在一个事务中，所以只读到事务开始事务的数据，也就是重复读） |
select * from t: 1,2,3,4 |
| ? |
? |
? |
? |
commit（提交事务，下面的就是一个新的事务，所以可以读到事务提交以后的最新数据） |
? |
| ? |
? |
? |
? |
select * from t: 1,2,3,4 |
? |
| READ-UNCOMMITTED 会产生脏读，基本很少适用于实际场景，所以基本不使用。 |
|||||
实验二：测试READ-COMMITTED与REPEATABLE-READ
| 事务A |
事务B READ-COMMITTED |
事务C REPEATABLE-READ |
| set autocommit =0; |
? |
? |
| start transaction ; |
start transaction; |
start transaction; |
| insert into t(a)values(4); |
? |
? |
| ? |
? select * from t; 1,2,3 |
? select * from t; 1,2,3 |
| ? |
? |
? |
| ? |
? |
? |
| commit; |
? |
? |
| ? |
select * from t: 1,2,3,4 |
select * from t: 1,2,3（重复读：由于与上面的在一个事务中，所以只读到事务开始事务的数据，也就是重复读） |
| ? |
? |
commit（提交事务，下面的就是一个新的事务，所以可以读到事务提交以后的最新数据） |
| ? |
? |
select * from t: 1,2,3,4 |
| REPEATABLE-READ可以确保一个事务中读取的数据是可重复的，也就是相同的读取（第一次读取以后，即使其他事务已经提交新的数据，同一个事务中再次select也并不会被读取）。 READ-COMMITTED只是确保读取最新事务已经提交的数据。 |
||
当然数据的可见性都是对不同事务来说的，同一个事务，都是可以读到此事务中最新数据的。
starttransaction;
insertinto t(a)values(4);
select *from t;
1,2,3,4;
insertinto t(a)values(5);
select *from t;
1,2,3,4,5;
实验三：测试SERIALIZABLE事务对其他的影响
| 事务A SERIALIZABLE |
事务B READ-UNCOMMITTED |
事务C READ-COMMITTED, |
事务D REPEATABLE-READ |
事务E SERIALIZABLE |
| set autocommit =0; |
? |
? |
? |
? |
| start transaction ; |
? |
? |
start transaction; |
? |
| select a from t union all select sleep(1000) from dual; |
? |
? |
? |
? |
| ? |
? insert into t(a)values(5); |
? insert into t(a)values(5); |
? insert into t(a)values(5); |
insert into t(a)values(5); |
| ? |
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction |
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction |
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction |
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction |
| ? |
SERIALIZABLE 串行化执行，导致所有其他事务不得不等待事务A结束才行可以执行，这里特意使用了sleep函数，直接导致事务B,C,D,E等待事务A持有释放的锁。由于我sleep了1000秒，而innodb_lock_wait_timeout为120 | |||