【MySql】08 笔记 事务是隔离的还是不隔离的

一、问题

1、一个事务要更新一行，如果刚好有另外一个事务拥有这一行的行锁，它又不能操作，会被锁住，进入等待状态。问题
是，既然进入了等待状态，那么等到这个事务自己获取到行锁要更新数据的时候，它读到的值是什么?

create table `t`(

`id` int(11) NOT NULL,
`k` int(11) DEFAULT NULL,
primary key(`id`)
) ENGINE = InnoDB;
insert into t(id, k) values(1,1),(2,2);

事务A	事务B	事务C
start transaction with consistent snapshot	无	无
无	start transaction with consistent snapshot	无
无	无	update t set k=k+1 where id=1;
无	update t set k=k+1 where id=1;	无
无	select k from t where id=1;	无
select k from t where id=1;	无	无
commit	无	无
无	commit	无

1. begin/start transaction 命令并不是一个事务的起点，在执行到它们之后的第一个操作InnoDB表的语句，事务才真正启动。一致性视图是在第执行第一个快照读语句时创建的;

2. 立即启动一个事务使用 start transaction with consistent snapshot 这个命令。一致性视图是在执行 start transaction with consistent snapshot 时创建的。

3. 事务 B 查到的 k 的值是 3，事务 A 查到的 k 的值是 1

二、MySQL两个“视图”

1、 view

是一个用查询语句定义的虚拟表，在调用的时候执行查询语句并生成结果。创建视图的语法是 create view … ，而它的查询方法与表一样。

2、consistent read view => InnoDB 在实现 MVCC 时用到的一致性读视图

1. 用于支持 RC(Read Committed，读提交)和 RR(Repeatable Read，可重复读)隔离 级别的实现。

2. 作用是事务执行期间用来定义“操作者能看到什么数据”

三、“快照”在 MVCC工作流程

1、在可重复读隔离级别下，事务在启动的时候就“拍了个快照” => 是基于整库的。

2、InnoDB 里面每个事务有一个唯一的事务 D。

1. transaction id : 是在事务开始的时 候向 InnoDB 的事务系统申请的，是按申请顺序严格递增的。

2. 每行数据也都是有多个版本的。每次事务更新数据的时候，都会生成一个新的数据版本， 并且把 transaction id赋值给这个数据版本的事务 ID，记为row trx_id。同时，旧的数据版本要保留，并且在新的数据版本中，能够有信息可以直接拿到它。

3. 数据表中的一行记录，其实可能有多个版本 (row)，每个版本有自己的 row trx_id。

k	v	操作	row trx_id	transaction id
1	v1	无	10	10
10	v2	set key=10	15	15
11	v3	set key=11	17	17
18	v4	set key=18	20	20

4. transaction id=row trx_id

5. V1、V2、V3 并不是物理上真实存 在的，而是每次需要的时候根据当前版本和 undo log 计算出来的。比如，需要 V2 的时 候，就是通过 V4 依次执行 U3、U2 算出来。

6. 可重复读的定义，一个事务启动的时候，能够看到所有已经提交的事务结果。但是之后，这个事务执行期间，其他事务的更新对它不可见。

3、视图数组和高水位 => 组成了当前事务的一致性视图(read-view)

当前事务启动,启动以后生成的不可见,事务前可见。

4、一个数据版本的 row trx_id 的几种可能

1. 如果落在已经提交事务部分，表示这个版本是已提交的事务或者是当前事务自己生成的这个数 据是可见的;

2. 如果落在未开始事务部分，表示这个版本是由将来启动的事务生成的，是肯定不可见的;

3. 如果落在事务未提交事务集合部分，那就包括两种情况

a. 若 row trx_id 在数组中，表示这个版本是由还没提交的事务生成的，不可见;

b. 若 row trx_id 不在数组中，表示这个版本是已经提交了的事务生成的，可见。

5、例子 分析下事务 A 的语句返回的结果

1. 事务 A 开始前，系统里面只有一个活跃事务 ID 是 99;

2. 事务 A、B、C 的版本号分别是 100、101、102，且当前系统里只有这四个事务;

3. 三个事务开始前，(1,1)这一行数据的 row trx_id 是 90。

事务 A 的视图数组就是 [99,100], 事务 B 的视图数组是 [99,100,101], 事务 C 的视 图数组是 [99,100,101,102]。

6、分析

1. 第一个有效更新是事务 C，把数据从 (1,1) 改成了 (1,2)。这个 数据的最新版本的 row trx_id 是 102，而 90 这个版本已经成为了历史版本。

2. 第二个有效更新是事务 B，把数据从 (1,2) 改成了 (1,3)。这个数据的最新版本(即 row trx_id)是 101，而 102 又成为了历史版本。

3. 在事务 A 查询的时候，事务 B 还没有提交，但是它生成的 (1,3) 这 个版本已经变成当前版本了。但这个版本对事务 A 必须是不可见的，否则就变成脏读。

4. 现在事务 A 要来读数据了，它的视图数组是 [99,100],从当前101 判断

a: row trx_id=101，比高水位大 不可见

b: 找到上一个历史版本，一看 row trx_id=102，比高水位大 不可见

c: 终于找到了(1,1)，它的 row trx_id=90，比低水位小 可见

7、总结

一个数据版本，对于一个事务视图来说，除了自己的更新总是可见以外，有三种情况:

1. 版本未提交，不可见;
2. 版本已提交，但是是在视图创建后提交的，不可见;
3. 版本已提交，而且是在视图创建前提交的，可见。

四、更新逻辑

1、事务 B 的 update 语句，如果按照一致性读 应该是事务 B 的视图数组是先生成的，之后事务 C 才提交，不是应该看不见 (1,2) 吗，怎么能算出 (1,3) 来?

1. 事务 B 在更新之前查询一次数据，这个查询返回的 k 的值是 1。

2. 更新数据都是先读后写的，而这个读，只能读当前的 值，称为“当前读”(current read)。

3. 执行事务 B 查询语句的时候，一看自己的版本号是 101，最新数据的版本号也是101，是自己的更新，可以直接使用，所以查询得到的 k 的值是 3。

2、当前读

1. 除 update 语句外，select 语句如果加锁，也是当前读。

> select k from t where id = 1 lock in share mode; // 加了读锁(S 锁，共享锁)
> select k from t where id = 1 for update; // 写锁(X 锁，排他锁)

五、小结

1、对于可重复读，查询只承认在事务启动前就已经提交完成的数据;

2、对于读提交，查询只承认在语句启动前就已经提交完成的数据;

3、而当前读，总是读取已经提交完成的最新版本。