MySQL 中隔离级别 RC 与 RR 的区别

1. 数据库事务ACID特性

数据库事务的4个特性：
原子性(Atomic): 事务中的多个操做，不可分割，要么都成功，要么都失败； All or Nothing.
一致性(Consistency): 事务操做以后, 数据库所处的状态和业务规则是一致的; 好比a,b帐户相互转帐以后，总金额不变；
隔离性(Isolation): 多个事务之间就像是串行执行同样，不相互影响;
持久性(Durability): 事务提交后被持久化到永久存储.

2. 隔离性

其中 隔离性 分为了四种：

READ UNCOMMITTED：能够读取未提交的数据，未提交的数据称为脏数据，因此又称脏读。此时：幻读，不可重复读和脏读均容许；
READ COMMITTED：只能读取已经提交的数据；此时：容许幻读和不可重复读，但不容许脏读，因此RC隔离级别要求解决脏读；
REPEATABLE READ：同一个事务中屡次执行同一个select,读取到的数据没有发生改变；此时：容许幻读，但不容许不可重复读和脏读，因此RR隔离级别要求解决不可重复读；
SERIALIZABLE: 幻读，不可重复读和脏读都不容许，因此serializable要求解决幻读；

3. 几个概念

脏读：能够读取未提交的数据。RC 要求解决脏读；

不可重复读：同一个事务中屡次执行同一个select, 读取到的数据发生了改变(被其它事务update而且提交)；

可重复读：同一个事务中屡次执行同一个select, 读取到的数据没有发生改变(通常使用MVCC实现)；RR各级级别要求达到可重复读的标准；

幻读：同一个事务中屡次执行同一个select, 读取到的数据行发生改变。也就是行数减小或者增长了(被其它事务delete/insert而且提交)。SERIALIZABLE要求解决幻读问题；

这里必定要区分 不可重复读 和 幻读：

不可重复读的重点是修改:
一样的条件的select, 你读取过的数据, 再次读取出来发现值不同了

幻读的重点在于新增或者删除:
一样的条件的select, 第1次和第2次读出来的记录数不同

从结果上来看, 二者都是为屡次读取的结果不一致。但若是你从实现的角度来看, 它们的区别就比较大：
对于前者, 在RC下只须要锁住知足条件的记录，就能够避免被其它事务修改，也就是 select for update, select in share mode; RR隔离下使用MVCC实现可重复读；
对于后者, 要锁住知足条件的记录及全部这些记录之间的gap，也就是须要 gap lock。

而ANSI SQL标准没有从隔离程度进行定义，而是定义了事务的隔离级别，同时定义了不一样事务隔离级别解决的三大并发问题：

solation Level	Dirty Read	Unrepeatable Read	Phantom Read
Read UNCOMMITTED	YES	YES	YES
READ COMMITTED	NO	YES	YES
READ REPEATABLE	NO	NO	YES
SERIALIZABLE	NO	NO	NO

参见：你真的明白事务的隔离性吗？ (姜承尧)

4. 数据库的默认隔离级别

除了MySQL默认采用RR隔离级别以外，其它几大数据库都是采用RC隔离级别。

可是他们的实现也是极其不同的。Oracle仅仅实现了RC 和 SERIALIZABLE隔离级别。默认采用RC隔离级别，解决了脏读。可是容许不可重复读和幻读。其SERIALIZABLE则解决了脏读、不可重复读、幻读。

MySQL的实现：MySQL默认采用RR隔离级别，SQL标准是要求RR解决不可重复读的问题，可是由于MySQL采用了gap lock，因此实际上MySQL的RR隔离级别也解决了幻读的问题。那么MySQL的SERIALIZABLE是怎么回事呢？其实MySQL的SERIALIZABLE采用了经典的实现方式，对读和写都加锁。

5. MySQL 中RC和RR隔离级别的区别

MySQL数据库中默认隔离级别为RR，可是实际状况是使用RC 和 RR隔离级别的都很多。好像淘宝、网易都是使用的 RC 隔离级别。那么在MySQL中 RC 和 RR有什么区别呢？咱们该如何选择呢？为何MySQL将RR做为默认的隔离级别呢？

5.1 RC 与 RR 在锁方面的区别

1> 显然 RR 支持 gap lock(next-key lock) (间隙锁)，而RC则没有gap lock。由于MySQL的RR须要gap lock来解决幻读问题。而RC隔离级别则是容许存在不可重复读和幻读的。因此RC的并发通常要好于RR；

2> RC 隔离级别，经过 where 条件过滤以后，不符合条件的记录上的行锁，会释放掉(虽然这里破坏了“两阶段加锁原则”)；可是RR隔离级别，即便不符合where条件的记录，也不会是否行锁和gap lock；因此从锁方面来看，RC的并发应该要好于RR；另外 insert into t select ... from s where 语句在s表上的锁也是不同的，参见下面的例子2；

例子1：

下面是来自 itpub 的一个例子：http://www.itpub.net/thread-1941624-1-1.html

MySQL5.6, 隔离级别RR，autocommit=off;

表结构：

mysql> show create table t1\G
*************************** 1. row ***************************
       Table: t1
Create Table: CREATE TABLE `t1` (
  `a` int(11) NOT NULL,
  `b` int(11) NOT NULL,
  `c` int(11) NOT NULL,
  `d` int(11) NOT NULL,
  `e` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`a`),
  KEY `idx_t1_bcd` (`b`,`c`,`d`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1
row in set (0.00 sec)

表数据：

mysql> select * from t1;
+---+---+---+---+------+
| a | b | c | d | e    |
+---+---+---+---+------+
| 1 | 1 | 1 | 1 | a    |
| 2 | 2 | 2 | 2 | b    |
| 3 | 3 | 2 | 2 | c    |
| 4 | 3 | 1 | 1 | d    |
| 5 | 2 | 3 | 5 | e    |
| 6 | 6 | 4 | 4 | f    |
| 7 | 4 | 5 | 5 | g    |
| 8 | 8 | 8 | 8 | h    |
+---+---+---+---+------+
rows in set (0.00 sec)

操做过程：

session 1:

delete from t1 where b>2 and b<5 and c=2;

执行计划以下：

mysql> explain select * from t1 where b>2 and b<5 and c=2\G
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: t1
         type: range
possible_keys: idx_t1_bcd
          key: idx_t1_bcd
      key_len: 4
          ref: NULL
         rows: 2
        Extra: Using index condition
row in set (0.00 sec)

session 2:

delete from t1 where a=4

结果 session 2 被锁住。

session 3:

mysql> select * from information_schema.innodb_locks;
+---------------+-------------+-----------+-----------+-------------+------------+------------+-----------+----------+-----------+
| lock_id       | lock_trx_id | lock_mode | lock_type | lock_table  | lock_index | lock_space | lock_page | lock_rec | lock_data |
+---------------+-------------+-----------+-----------+-------------+------------+------------+-----------+----------+-----------+
| 38777:390:3:5 | 38777       | X         | RECORD    | `test`.`t1` | PRIMARY    |        390 |         3 |        5 | 4         |
| 38771:390:3:5 | 38771       | X         | RECORD    | `test`.`t1` | PRIMARY    |        390 |         3 |        5 | 4         |
+---------------+-------------+-----------+-----------+-------------+------------+------------+-----------+----------+-----------+

根据锁及ICP的知识，此时加锁的状况应该是在索引  idx_t1_bcd 上的b>2 and b<5之间加gap lock, idx_t1_bcd 上的c=2 加 X锁主键 a=3 加 x 锁。
应该a=4上是没有加X锁的，能够进行删除与更改。
可是从session3上的结果来，此时a=4上被加上了X锁。

-------

要理解这里为何 a=4 被锁住了，须要理解 gap lock，锁处理 RR 隔离级别和RC隔离级别的区别等等。

这里的缘由以下：

很简单，咱们注意到：key_len: 4 和 Extra: Using index condition
这说明了，仅仅使用了索引 idx_t1_bcd 中的 b 一列，没有使用到 c 这一列。c 这一列是在ICP时进行过滤的。因此：

delete from t1 where b>2 and b<5 and c=2 其实锁定的行有：

mysql> select * from t1 where b>2 and b<=6;
+---+---+---+---+------+
| a | b | c | d | e    |
+---+---+---+---+------+
| 3 | 3 | 2 | 2 | c    |
| 4 | 3 | 1 | 1 | d    |
| 6 | 6 | 4 | 4 | f    |
| 7 | 4 | 5 | 5 | g    |
+---+---+---+---+------+
rows in set (0.00 sec)

因此显然 delete from t1 where a=4 就被阻塞了。那么为何 delete from t1 where a=6 也会被阻塞呢？？？

这里 b<=6 的缘由是，b 列中没有等于 5 的记录，因此 and b<5 实现为锁定 b<=6 的全部索引记录，这里有等于号的缘由是，若是咱们不锁定 =6 的索引记录，那么怎么实现锁定 <5 的gap 呢？也就是说锁定 b=6 的索引记录，是为了实现锁定 b< 5 的gap。也就是不能删除 b=6 记录的缘由。
而这里 b >2 没有加等于号(b>=2) 的缘由，是由于 b>2的这个gap 是由 b=3这个索引记录(的gap)来实现的，不是由 b=2索引记录(的gap) 来实现的，b=2的索引记录的gap lock只能实现锁定<2的gap，b>2的gap锁定功能，须要由 b=3的索引记录对应的gap来实现(b>2，b<3的gap)。
因此咱们在session2中能够删除：a=1,2,5,8的记录，可是不能删除 a=6(由于该行的b=6)的记录。

若是咱们使用 RC 隔离级别时，则不会发生阻塞，其缘由就是：

RC和RR隔离级别中的锁处理不同，RC隔离级别时，在使用c列进行ICP where条件过滤时，对于不符合条件的记录，锁会释放掉，而RR隔离级别时，即便不符合条件的记录，锁也不会释放(虽然违反了“2阶段锁”原则)。因此RC隔离级别时session 2不会被阻塞。

Gap lock: This is a lock on a gap between index records, or a lock on the gap before the first or after the last index record.

 

例子2：

insert into t select ... from s where 在RC 和 RR隔离级别下的加锁过程

下面是官方文档中的说明：http://dev.mysql.com/doc/refman/5.6/en/innodb-locks-set.html

INSERT INTO T SELECT ... FROM S WHERE ... sets an exclusive index record lock (without a gap lock) on each row inserted into T. If the transaction isolation level is READ COMMITTED, or innodb_locks_unsafe_for_binlog is enabled and the transaction isolation level is not SERIALIZABLE, InnoDB does the search on S as a consistent read (no locks). Otherwise, InnoDB sets shared next-key locks on rows from S. InnoDB has to set locks in the latter case: In roll-forward recovery from a backup, every SQL statement must be executed in exactly the same way it was done originally.

CREATE TABLE ... SELECT ... performs the SELECT with shared next-key locks or as a consistent read, as for INSERT ... SELECT.

When a SELECT is used in the constructs REPLACE INTO t SELECT ... FROM s WHERE ... or UPDATE t ... WHERE col IN (SELECT ... FROM s ...), InnoDB sets shared next-key locks on rows from table s.

insert inot t select ... from s where ... 语句和 create table ... select ... from s where 加锁过程是类似的(RC 和 RR 加锁不同)：

1> RC 隔离级别时和 RR隔离级别可是设置innodb_locks_unsafe_for_binlog=1 时，select ... from s where 对 s 表进行的是一致性读，因此是无需加锁的；

2> 若是是RR隔离级别(默认innodb_locks_unsafe_for_binlog=0)，或者是 serializable隔离级别，那么对 s 表上的每一行都要加上 shared next-key lock.

这个区别是一个很大的不一样，下面是生成中的一个 insert into t select ... from s where 致使的系统宕机的案例：

一程序猿执行一个分表操做：

insert into tb_async_src_acct_201508 select * from tb_async_src_acct 

where src_status=3 and create_time>='2015-08-01 00:00:00' and create_time <= '2015-08-31 23:59:59';

表 tb_async_src_acct有4000W数据。分表的目的是想提高下性能。结果一执行该语句，该条SQL被卡住，而后全部向 tb_async_src_acct的写操做，要么是 get lock fail, 要么是 lost connection，所有卡住，而后主库就宕机了。

显然这里的缘由，就是不知道默认RR隔离级别中 insert into t select ... from s where 语句的在 s 表上的加锁过程，该语句一执行，全部符合 where 条件的 s 表中的行记录都会加上 shared next-key lock(若是没有使用到索引，还会锁住表中全部行)，在整个事务过程当中一直持有，由于表 tb_async_src_acct 数据不少，因此运行过程是很长的，因此加锁过程也是很长，因此其它全部的对 tb_async_src_acct 的insert, delete, update, DDL 都会被阻塞掉，这样被阻塞的事务就愈来愈多，而事务也会申请其它的表中的行锁，结果就是系统中被卡住的事务愈来愈多，系统天然就宕机了。

5.2 RC 与 RR 在复制方面的区别

1> RC 隔离级别不支持 statement 格式的bin log，由于该格式的复制，会致使主从数据的不一致；只能使用 mixed 或者 row 格式的bin log; 这也是为何MySQL默认使用RR隔离级别的缘由。复制时，咱们最好使用：binlog_format=row

具体参见：

http://blog.itpub.net/29254281/viewspace-1081678/

http://www.cnblogs.com/vinchen/archive/2012/11/19/2777919.html

2> MySQL5.6 的早期版本，RC隔离级别是能够设置成使用statement格式的bin log，后期版本则会直接报错；

5.3 RC 与 RR 在一致性读方面的区别

简单并且，RC隔离级别时，事务中的每一条select语句会读取到他本身执行时已经提交了的记录，也就是每一条select都有本身的一致性读ReadView; 而RR隔离级别时，事务中的一致性读的ReadView是以第一条select语句的运行时，做为本事务的一致性读snapshot的创建时间点的。只能读取该时间点以前已经提交的数据。

具体能够参加：MySQL 一致性读 深刻研究

5.4 RC 支持半一致性读，RR不支持

RC隔离级别下的update语句，使用的是半一致性读(semi consistent)；而RR隔离级别的update语句使用的是当前读；当前读会发生锁的阻塞。

1> 半一致性读：

A type of read operation used for UPDATE statements, that is a combination of read committed and consistent read. When an UPDATE statement examines a row that is already locked, InnoDB returns the latest committed version to MySQL so that MySQL can determine whether the row matches the WHERE condition of the UPDATE. If the row matches (must be updated), MySQL reads the row again, and this time InnoDB either locks it or waits for a lock on it. This type of read operation can only happen when the transaction has the read committed isolation level, or when the innodb_locks_unsafe_for_binlog option is enabled.

简单来讲，semi-consistent read是read committed与consistent read二者的结合。一个update语句，若是读到一行已经加锁的记录，此时InnoDB返回记录最近提交的版本，由MySQL上层判断此版本是否知足 update的where条件。若知足(须要更新)，则MySQL会从新发起一次读操做，此时会读取行的最新版本(并加锁)。semi-consistent read只会发生在read committed隔离级别下，或者是参数innodb_locks_unsafe_for_binlog被设置为true(该参数即将被废弃)。

对比RR隔离级别，update语句会使用当前读，若是一行被锁定了，那么此时会被阻塞，发生锁等待。而不会读取最新的提交版本，而后来判断是否符合where条件。

半一致性读的优势：

减小了update语句时行锁的冲突；对于不知足update更新条件的记录，能够提早放锁，减小并发冲突的几率。

具体能够参见：http://hedengcheng.com/?p=220

Oracle中的update好像有“重启动”的概念。