实例分析MySQL下的四种事务隔离级别

数据库事务有四种隔离级别：

创新互联建站是一家专业从事成都网站设计、成都做网站的网络公司。作为专业网络公司,创新互联建站依托的技术实力、以及多年的网站运营经验,为您提供专业的成都网站建设、网络营销推广及网站设计开发服务！

  • 未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据。
  • 提交读(Read Committed)：只能读取到已经提交的数据，Oracle等多数数据库默认都是该级别。
  • 可重复读(Repeated Read)：可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻读。
  • 串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞。

上面这样的教科书式定义***次接触事务隔离概念的朋友看了可能会一脸懵逼，下面我们就通过具体的实例来解释四个隔离级别。

首先我们创建一个user表：

 
 
 
 
    
  
  
  
  
  1. CREATE TABLE user ( 
    2. 
  
  
  
  
  2.     `id` int(11) NOT NULL AUTO_INCREMENT, 
    3. 
  
  
  
  
  3.     `name` varchar(255) NOT NULL, 
    4. 
  
  
  
  
  4.     PRIMARY KEY (`id`), 
    5. 
  
  
  
  
  5.     UNIQUE `uniq_name` USING BTREE (name) 
    6. 
  
  
  
  
  6. ) ENGINE=`InnoDB` AUTO_INCREMENT=10 DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; 
    7.

 

读未提交隔离级别

我们先将事务的隔离级别设置为read committed：

 
 
 
 
    
  
  
  
  
  1. mysql> set session transaction isolation level read uncommitted; 
    2. 
  
  
  
  
  2. Query OK, 0 rows affected (0.00 sec) 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. mysql> select @@session.tx_isolation; 
    5. 
  
  
  
  
  5. +------------------------+ 
    6. 
  
  
  
  
  6. | @@session.tx_isolation | 
    7. 
  
  
  
  
  7. +------------------------+ 
    8. 
  
  
  
  
  8. | READ-UNCOMMITTED       | 
    9. 
  
  
  
  
  9. +------------------------+ 
    10. 
  
  
  
  
  10. 1 row in set (0.00 sec) 
    11.

 

在下面我们开了两个终端分别用来模拟事务一和事务二，p.s: 操作一和操作二的意思是按照时间顺序来执行的。

事务1

 
 
 
 
    
  
  
  
  
  1. mysql> start transaction; # 操作1 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Query OK, 0 rows affected (0.00 sec) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. mysql> insert into user(name) values('ziwenxie'); # 操作3 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. Query OK, 1 row affected (0.05 sec) 
    8.

 

事务2

 
 
 
 
    
  
  
  
  
  1. mysql> start transaction; # 操作2 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Query OK, 0 rows affected (0.00 sec) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. mysql> select * from user; # 操作4 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. +----+----------+ 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. | id | name | 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. +----+----------+ 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. | 10 | ziwenxie | 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. +----+----------+ 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. 1 row in set (0.00 sec) 
    18.

 

从上面的执行结果可以和清晰的看出来，在read uncommited级别下面我们在事务一中可能会读取到事务二中没有commit的数据，这就是脏读。

读提交隔离级别

通过设置隔离级别为committed可以解决上面的脏读问题。

 
 
 
 
    
  
  
  
  
  1. mysql> set session transaction isolation level read committed; 
    2.

事务一

 
 
 
 
    
  
  
  
  
  1. mysql> start transaction; # 操作一 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Query OK, 0 rows affected (0.00 sec) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. mysql> select * from user; # 操作三 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. +----+----------+ 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. | id | name | 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. +----+----------+ 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. | 10 | ziwenxie | 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. +----+----------+ 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. 1 row in set (0.00 sec) 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. mysql> select * from user; # 操作五，操作四的修改并没有影响到事务一 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. +----+----------+ 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. | id | name | 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. +----+----------+ 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. | 10 | ziwenxie | 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. +----+----------+ 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31. 1 row in set (0.00 sec) 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33. mysql> select * from user; # 操作七 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. +----+------+ 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37. | id | name | 
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39. +----+------+ 
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41. | 10 | lisi | 
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43. +----+------+ 
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45. 1 row in set (0.00 sec) 
    46. 
  
  
  
  
  46.  
    47. 
  
  
  
  
  47. mysql> commit; # 操作八 
    48. 
  
  
  
  
  48.  
    49. 
  
  
  
  
  49. Query OK, 0 rows affected (0.00 sec) 
    50.

 

事务二

 
 
 
 
    
  
  
  
  
  1. mysql> start transaction; # 操作二 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Query OK, 0 rows affected (0.00 sec) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. mysql> update user set name='lisi' where id=10; # 操作四 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. Query OK, 1 row affected (0.06 sec) 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. Rows matched: 1 Changed: 1 Warnings: 0 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. mysql> commit; # 操作六 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. Query OK, 0 rows affected (0.08 sec) 
    14.

 

虽然脏读的问题解决了，但是注意在事务一的操作七中，事务二在操作六commit后会造成事务一在同一个transaction中两次读取到的数据不同，这就是不可重复读问题，使用第三个事务隔离级别repeatable read可以解决这个问题。

可重复读隔离级别

MySQL的Innodb存储引擎默认的事务隔离级别就是可重复读隔离级别，所以我们不用进行多余的设置。

事务一

 
 
 
 
    
  
  
  
  
  1. mysql> start tansactoin; # 操作一 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. mysql> select * from user; # 操作五 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. +----+----------+ 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. | id | name | 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. +----+----------+ 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. | 10 | ziwenxie | 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. +----+----------+ 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. 1 row in set (0.00 sec) 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. mysql> commit; # 操作六 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. Query OK, 0 rows affected (0.00 sec) 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. mysql> select * from user; # 操作七 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. +----+------+ 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. | id | name | 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. +----+------+ 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. | 10 | lisi | 
    30. 
  
  
  
  
  30.  
    31. 
  
  
  
  
  31. +----+------+ 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33. 1 row in set (0.00 sec) 
    34.

 

事务二

 
 
 
 
    
  
  
  
  
  1. mysql> start tansactoin; # 操作二 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. mysql> update user set name='lisi' where id=10; # 操作三 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. Query OK, 1 row affected (0.00 sec) 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. Rows matched: 1 Changed: 1 Warnings: 0 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. mysql> commit; # 操作四 
    10.

 

在事务一的操作五中我们并没有读取到事务二在操作三中的update，只有在commit之后才能读到更新后的数据。

Innodb解决了幻读么

实际上RR级别是可能产生幻读，InnoDB引擎官方称中利用MVCC多版本并发控制解决了这个问题，下面我们验证一下Innodb真的解决了幻读了么?

为了方便展示，我修改了一下上面的user表：

 
 
 
 
    
  
  
  
  
  1. mysql> alter table user add salary int(11); 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Query OK, 0 rows affected (0.51 sec) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. Records: 0 Duplicates: 0 Warnings: 0 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. mysql> delete from user; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. Query OK, 1 rows affected (0.07 sec) 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. mysql> insert into user(name, salary) value('ziwenxie', 88888888); 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. Query OK, 1 row affected (0.07 sec) 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. mysql> select * from user; 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. +----+----------+----------+ 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. | id | name | salary | 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. +----+----------+----------+ 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. | 10 | ziwenxie | 88888888 | 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. +----+----------+----------+ 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. 1 row in set (0.00 sec) 
    28.

 

事务一

 
 
 
 
    
  
  
  
  
  1. mysql> start transaction; # 操作一 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Query OK, 0 rows affected (0.00 sec) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. mysql> update user set salary='4444'; # 操作六，竟然影响了两行，不是说解决了幻读么? 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. Query OK, 2 rows affected (0.00 sec) 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. Rows matched: 2 Changed: 2 Warnings: 0 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. mysql> select * from user; # 操作七， Innodb并没有完全解决幻读 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. +----+----------+--------+ 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15. | id | name | salary | 
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17. +----+----------+--------+ 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. | 10 | ziwenxie | 4444 | 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. | 11 | zhangsan | 4444 | 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. +----+----------+--------+ 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. 2 rows in set (0.00 sec) 
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27. mysql> commit; # 操作八 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. Query OK, 0 rows affected (0.04 sec) 
    30.

 

事务二

 
 
 
 
    
  
  
  
  
  1. mysql> start transaction; # 操作二 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. Query OK, 0 rows affected (0.00 sec) 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. mysql> insert into user(name, salary) value('zhangsan', '666666'); # 操作四 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7. Query OK, 1 row affected (0.00 sec) 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. mysql> commit; # 操作五 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11. Query OK, 0 rows affected (0.04 sec) 
    12.

 

从上面的例子可以看出，Innodb并没有如官方所说解决幻读，不过上面这样的场景中也不是很常见不用过多的担心。

串行化隔离级别

所有事务串行执行，***隔离级别，不会出现幻读性能会很差，实际开发中很少使用到。

分享标题：实例分析MySQL下的四种事务隔离级别
分享链接：http://www.shufengxianlan.com/qtweb/news48/144348.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

Google知识

同城分类信息

奢侈品网站建设方案　　 　全网营销　　 　外贸网站建设　　 　手机微信网站　　 　橡塑保温板　　 　护栏打桩机　　 　成都网站建设　　 　重庆APP开发　　 　腾讯云香港免备案空间　　 　边坡柔性防护网　　 　都江堰网站建设　　 　内江广告　　 　成都做网站　　 　成都网站设计公司　　 　响应式网站建设　　 　网站建设推广　　 　重庆水土机房托管　　 　眉山服务器托管　　 　成都网站推广　　 　雨棚定制