MySQL 四种事务隔离级别详解及对比--转
http://www.jb51.net/article/100183.htm
接的隔离级别。它的语法如下:
1
|
SET [SESSION | GLOBAL ] TRANSACTION ISOLATION LEVEL { READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE }
|
注意:默认的行为(不带session和global)是为下一个(未开始)事务设置隔离级别。如果你使用GLOBAL关键字,语句在全局对从那点开始创建的所有新连接(除了不存在的连接)设置默认事务级别。你需要SUPER权限来做这个。使用SESSION 关键字为将来在当前连接上执行的事务设置默认事务级别。 任何客户端都能自由改变会话隔离级别(甚至在事务的中间),或者为下一个事务设置隔离级别。
你可以用下列语句查询全局和会话事务隔离级别:
1
2
3
|
SELECT @@ global .tx_isolation;
SELECT @@session.tx_isolation;
SELECT @@tx_isolation;
|
----以上手册中的理论知识;
===========================================================================================
隔离级别 脏读(Dirty Read) 不可重复读(NonRepeatable Read) 幻读(Phantom Read)
===========================================================================================
未提交读(Read uncommitted) 可能 可能 可能
已提交读(Read committed) 不可能 可能 可能
可重复读(Repeatable read) 不可能 不可能 可能
可串行化(Serializable ) 不可能 不可能 不可能
===========================================================================================
·未提交读(Read Uncommitted):允许脏读,也就是可能读取到其他会话中未提交事务修改的数据
·提交读(Read Committed):只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别 (不重复读)
·可重复读(Repeated Read):可重复读。在同一个事务内的查询都是事务开始时刻一致的,InnoDB默认级别。在SQL标准中,该隔离级别消除了不可重复读,但是还存在幻象读
·串行读(Serializable):完全串行化的读,每次读都需要获得表级共享锁,读写相互都会阻塞
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
用例子说明各个级别的情况:
① 脏读: 脏读就是指当一个事务正在访问数据,并且对数据进行了修改,而这种修改还没有提交到数据库中,这时,另外一个事务也访问这个数据,然后使用了这个数据。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
session 1:
mysql> select @@ global .tx_isolation;
+ -----------------------+
| @@ global .tx_isolation |
+ -----------------------+
| REPEATABLE - READ |
+ -----------------------+
1 row in set (0.00 sec)
mysql> select @@session.tx_isolation;
+ -----------------------+
| @@session.tx_isolation |
+ -----------------------+
| REPEATABLE - READ |
+ -----------------------+
1 row in set (0.00 sec)
mysql> start transaction ;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into ttd values (1);
Query OK, 1 row affected (0.05 sec)
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 |
+ ------+
1 row in set (0.00 sec)
session 2:
mysql> select @@session.tx_isolation;
+ ------------------------+
| @@session.tx_isolation |
+ ------------------------+
| REPEATABLE - READ |
+ ------------------------+
1 row in set (0.00 sec)
mysql> select @@ global .tx_isolation;
+ -----------------------+
| @@ global .tx_isolation |
+ -----------------------+
| REPEATABLE - READ | --------该隔离级别下(除了 read uncommitted)
+ -----------------------+
1 row in set (0.00 sec)
mysql> select * from ttd;
Empty set (0.00 sec) --------不会出现脏读
mysql> set session transaction isolation level read uncommitted ;
Query OK, 0 rows affected (0.00 sec)
mysql> select @@session.tx_isolation;
+ ------------------------+
| @@session.tx_isolation |
+ ------------------------+
| READ - UNCOMMITTED | --------该隔离级别下
+ ------------------------+
1 row in set (0.00 sec)
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 | --------REPEATABLE-READ级别出现脏读
+ ------+
1 row in set (0.00 sec)
|
结论:session 2 在READ-UNCOMMITTED 下读取到session 1 中未提交事务修改的数据.
② 不可重复读:是指在一个事务内,多次读同一数据。在这个事务还没有结束时,另外一个事务也访问该同一数据。那么,在第一个事务中的两次读数据之间,由于第二个事务的修改,那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的,因此称为是不可重复读。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
session 1:
mysql> select @@session.tx_isolation;
+ ------------------------+
| @@session.tx_isolation |
+ ------------------------+
| READ - COMMITTED |
+ ------------------------+
1 row in set (0.00 sec)
mysql> start transaction ;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 |
+ ------+
1 row in set (0.00 sec)
session 2 :
mysql> select @@session.tx_isolation;
+ ------------------------+
| @@session.tx_isolation |
+ ------------------------+
| REPEATABLE - READ |
+ ------------------------+
1 row in set (0.00 sec)
mysql> start transaction ;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 |
+ ------+
1 row in set (0.00 sec)
mysql> insert into ttd values (2); /也可以更新数据
Query OK, 1 row affected (0.00 sec)
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 |
| 2 |
+ ------+
2 rows in set (0.00 sec)
mysql> commit ;
Query OK, 0 rows affected (0.02 sec)
session 2 提交后,查看session 1 的结果;
session 1:
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 | --------和第一次的结果不一样,READ-COMMITTED 级别出现了不重复读
| 2 |
+ ------+
2 rows in set (0.00 sec)
|
③ 可重复读:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
session 1:
mysql> select @@session.tx_isolation;
+ ------------------------+
| @@session.tx_isolation |
+ ------------------------+
| REPEATABLE - READ |
+ ------------------------+
1 row in set (0.00 sec)
mysql> start transaction ;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 |
| 2 |
+ ------+
2 rows in set (0.00 sec)
session 2 :
mysql> select @@session.tx_isolation;
+ ------------------------+
| @@session.tx_isolation |
+ ------------------------+
| REPEATABLE - READ |
+ ------------------------+
1 row in set (0.00 sec)
mysql> start transaction ;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into ttd values (3);
Query OK, 1 row affected (0.00 sec)
mysql> commit ;
Query OK, 0 rows affected (0.03 sec)
session 2 提交后,查看session 1 的结果;
session 1:
mysql> select * from ttd;
+ ------+
| id |
+ ------+
| 1 | --------和第一次的结果一样,REPEATABLE-READ级别出现了重复读
| 2 |
+ ------+
2 rows in set (0.00 sec)
( commit session 1 之后 再 select * from ttd 可以看到session 2 插入的数据3)
|
④ 幻读:第一个事务对一个表中的数据进行了修改,这种修改涉及到表中的全部数据行。同时,第二个事务也修改这个表中的数据,这种修改是向表中插入一行新数据。那么,以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行,就好象发生了幻觉一样。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
mysql> CREATE TABLE `t_bitfly` (
`id` bigint (20) NOT NULL default '0' ,
`value` varchar (32) default NULL ,
PRIMARY KEY (`id`)
) ENGINE=InnoDB
mysql> select @@ global .tx_isolation, @@tx_isolation;
+ -----------------------+-----------------+
| @@ global .tx_isolation | @@tx_isolation |
+ -----------------------+-----------------+
| REPEATABLE - READ | REPEATABLE - READ |
+ -----------------------+-----------------+
实验一:
t Session A Session B
|
| START TRANSACTION ; START TRANSACTION ;
|
| SELECT * FROM t_bitfly;
| empty set
| INSERT INTO t_bitfly
| VALUES (1, 'a' );
|
| SELECT * FROM t_bitfly;
| empty set
| COMMIT ;
|
| SELECT * FROM t_bitfly;
| empty set
|
| INSERT INTO t_bitfly VALUES (1, 'a' );
| ERROR 1062 (23000):
| Duplicate entry '1' for key 1
v (shit, 刚刚明明告诉我没有这条记录的)
如此就出现了幻读,以为表里没有数据,其实数据已经存在了,傻乎乎的提交后,才发现数据冲突了。
实验二:
t Session A Session B
|
| START TRANSACTION ; START TRANSACTION ;
|
| SELECT * FROM t_bitfly;
| + ------+-------+
| | id | value |
| + ------+-------+
| | 1 | a |
| + ------+-------+
| INSERT INTO t_bitfly
| VALUES (2, 'b' );
|
| SELECT * FROM t_bitfly;
| + ------+-------+
| | id | value |
| + ------+-------+
| | 1 | a |
| + ------+-------+
| COMMIT ;
|
| SELECT * FROM t_bitfly;
| + ------+-------+
| | id | value |
| + ------+-------+
| | 1 | a |
| + ------+-------+
|
| UPDATE t_bitfly SET value= 'z' ;
| Rows matched: 2 Changed: 2 Warnings: 0
| (怎么多出来一行)
|
| SELECT * FROM t_bitfly;
| + ------+-------+
| | id | value |
| + ------+-------+
| | 1 | z |
| | 2 | z |
| + ------+-------+
|
本事务中第一次读取出一行,做了一次更新后,另一个事务里提交的数据就出现了。也可以看做是一种幻读。
当隔离级别是可重复读,且禁用innodb_locks_unsafe_for_binlog的情况下,在搜索和扫描index的时候使用的next-key locks可以避免幻读。
再看一个实验,要注意,表t_bitfly里的id为主键字段。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
实验三:
t Session A Session B
|
| START TRANSACTION; START TRANSACTION;
|
| SELECT * FROM t_bitfly
| WHERE id <=1
| FOR UPDATE;
| +------+-------+
| | id | value |
| +------+-------+
| | 1 | a |
| +------+-------+
| INSERT INTO t_bitfly
| VALUES (2, 'b' );
| Query OK, 1 row affected
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id | value |
| +------+-------+
| | 1 | a |
| +------+-------+
| INSERT INTO t_bitfly
| VALUES (0, '0' );
| (waiting for lock ... then timeout)
| ERROR 1205 (HY000):
| Lock wait timeout exceeded;
| try restarting transaction
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id | value |
| +------+-------+
| | 1 | a |
| +------+-------+
| COMMIT;
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id | value |
| +------+-------+
| | 1 | a |
| +------+-------+
|
可以看到,用id<=1加的锁,只锁住了id<=1的范围,可以成功添加id为2的记录,添加id为0的记录时就会等待锁的释放。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
实验四:一致性读和提交读
t Session A Session B
|
| START TRANSACTION; START TRANSACTION;
|
| SELECT * FROM t_bitfly;
| +----+-------+
| | id | value |
| +----+-------+
| | 1 | a |
| +----+-------+
| INSERT INTO t_bitfly
| VALUES (2, 'b' );
| COMMIT;
|
| SELECT * FROM t_bitfly;
| +----+-------+
| | id | value |
| +----+-------+
| | 1 | a |
| +----+-------+
|
| SELECT * FROM t_bitfly LOCK IN SHARE MODE;
| +----+-------+
| | id | value |
| +----+-------+
| | 1 | a |
| | 2 | b |
| +----+-------+
|
| SELECT * FROM t_bitfly FOR UPDATE;
| +----+-------+
| | id | value |
| +----+-------+
| | 1 | a |
| | 2 | b |
| +----+-------+
|
| SELECT * FROM t_bitfly;
| +----+-------+
| | id | value |
| +----+-------+
| | 1 | a |
| +----+-------+
|
如果使用普通的读,会得到一致性的结果,如果使用了加锁的读,就会读到“最新的”“提交”读的结果。
本身,可重复读和提交读是矛盾的。在同一个事务里,如果保证了可重复读,就会看不到其他事务的提交,违背了提交读;如果保证了提交读,就会导致前后两次读到的结果不一致,违背了可重复读。
可以这么讲,InnoDB提供了这样的机制,在默认的可重复读的隔离级别里,可以使用加锁读去查询最新的数据(提交读)。
MySQL InnoDB的可重复读并不保证避免幻读,需要应用使用加锁读来保证。而这个加锁度使用到的机制就是next-key locks。
总结:
四个级别逐渐增强,每个级别解决一个问题。事务级别越高,性能越差,大多数环境read committed 可以用.记住4个隔离级别的特点(上面的例子);
转载于:https://www.cnblogs.com/davidwang456/p/8759402.html
MySQL 四种事务隔离级别详解及对比--转相关推荐
- 数据库四种事务隔离级别详解
四种数据库隔离级别及解决的数据问题如下所示: 1.READ-UNCOMMITTED(读取未提交内容) 由于在该隔离级别下即使事务未提交所做的修改也会对其他事务产生影响.所以该级别会出现数据脏读的发生. ...
- mysql四种事务隔离级别
mysql事务并发问题 ACID什么的就不啰嗦了.mysql多个事务并发的时候,可能会出现如下问题: 1. 更新丢失 即两个事务同时更新某一条数据,后执行的更新操作会覆盖先执行的更新操作,导致先执行的 ...
- Mysql有四种事务隔离级别,详解脏读、不可重复读、幻读
Mysql的事务隔离级别 Mysql有四种事务隔离级别,这四种隔离级别代表当存在多个事务并发冲突时,可能出现的脏读.不可重复读.幻读的问题. 脏读 大家看一下,我们有两个事务,一个是 Transact ...
- mysql四种输入_mysql四种事务隔离级别
mysql事务并发问题 ACID什么的就不啰嗦了.mysql多个事务并发的时候,可能会出现如下问题: 1. 更新丢失 即两个事务同时更新某一条数据,后执行的更新操作会覆盖先执行的更新操作,导致先执行的 ...
- 【MySQL】MySQL的四种事务隔离级别
[MySQL]MySQL的四种事务隔离级别 本文实验的测试环境:Windows 10+cmd+MySQL5.6.36+InnoDB 一.事务的基本要素(ACID) 1.原子性(Atomicity):事 ...
- SQL Server事务隔离级别详解
SQL Server事务隔离级别详解 标签: SQL SEERVER/MSSQL SERVER/SQL/事务隔离级别选项/设置数据库事务级别 SQL 事务隔离级别 概述 隔离级别用于决定如果控制并发用 ...
- MYSQL事务隔离级别详解附加实验
参考: https://dev.mysql.com/doc/refman/5.7/en/set-transaction.html http://xm-king.iteye.com/blog/77072 ...
- MySQL事务隔离级别详解
SQL标准定义了4类隔离级别,包括了一些具体规则,用来限定事务内外的哪些改变是可见的,哪些是不可见的.低级别的隔离级一般支持更高的并发处理,并拥有更低的系统开销. Read Uncommitted(读 ...
- 数据库事务转载基础二:MySQL事务隔离级别详解
SQL标准定义了4类隔离级别,包括了一些具体规则,用来限定事务内外的哪些改变是可见的,哪些是不可见的.低级别的隔离级一般支持更高的并发处理,并拥有更低的系统开销. Read Uncommitted(读 ...
最新文章
- 架构体系需要进一步研究探索的V2路线图
- Nvidia: Mx150 CUDA10安装驱动
- 406(浏览器接收的响应类型和服务器返回的响应类型不匹配)
- NULL的陷阱:Merge
- linux登录界面主题,Ubuntu 12.10登录界面主题:Butterfly
- 什么浏览器好用_手机浏览器不只UC,好用的浏览器还有这些
- js 取闭合标签正则_js正则表达式解析html标签中的内容
- 关于Vue.js的v-for,key的顺序改变,影响过渡动画表现
- paip.java gui swt/jface 最佳实践
- javascript手册地址
- php 图片底色替换,手把手教你替换相片中的颜色(给相片换底色)
- 51单片机:独立按键
- Millet谷仓,揭秘你所不知道的区块链电商
- 前端显示和隐藏div的方法 / 判断
- IAR for MSP430 7_12在线调试不能打断点解决方法
- linux拷贝优先级,Linux快速入门之命令
- 烟气分析仪行业调研报告 - 市场现状分析与发展前景预测
- PWM 互补两个引脚输出相同的PWM波形 CH1 和CH1N
- 眼睛慢慢眯成一条线的人都是实力很强劲的,教你在Unity中通过BlendShape来实现角色面部表情过渡切换(Animation)
- 庄子,以自然之道,养自然之身
热门文章
- 暗黑三使用服务器维护,《暗黑3》本周更新修复内容及维护时间公布
- mod php是什么意思,mod函数是什么意思
- cas无法使用_一文彻底搞懂CAS实现原理
- spark 统计汉字字数_版面字数和实际字数一样吗
- 折纸机器人的步骤图解_折纸图解老虎
- python 常见函数_Python基础函数:初学者常用的十个Python函数,非常全面!
- 职工信息管理软件c语言大一,职工信息管理(C语言
- ListView嵌套RecyclerView遇到的一些坑以及解决办法
- php 菜谱 源码,基于php的菜谱大全api调用代码实例
- tensorflow-TFRecord 用法