Chinaunix首页 | 论坛 | 博客
  • 博客访问: 386885
  • 博文数量: 43
  • 博客积分: 613
  • 博客等级: 中士
  • 技术积分: 756
  • 用 户 组: 普通用户
  • 注册时间: 2008-09-01 11:25
文章分类

全部博文(43)

文章存档

2016年(1)

2015年(5)

2014年(5)

2013年(14)

2012年(18)

分类: Mysql/postgreSQL

2013-10-22 11:51:57

Read Uncommitted(读取未提交内容)

       在该隔离级别,所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用,因为它的性能也不比其他级别好多少。读取未提交的数据,也被称之为脏读(Dirty Read)。

用sql举例来表明:

点击(此处)折叠或打开

  1. 分别在A、B两个客户端执行:

  2. A:
  3. root@(none) 10:54>SET GLOBAL tx_isolation='READ-UNCOMMITTED';
  4. Query OK, 0 rows affected (0.00 sec)

  5. root@(none) 10:54>SELECT @@tx_isolation;
  6. +------------------+
  7. | @@tx_isolation |
  8. +------------------+
  9. | READ-UNCOMMITTED |
  10. +------------------+
  11. 1 row in set (0.00 sec)

  12. root@(none) 10:54>use test;
  13. Database changed
  14. root@test 10:55>begin;
  15. Query OK, 0 rows affected (0.00 sec)

  16. root@test 10:55>select * from test1;
  17. +------+
  18. | a |
  19. +------+
  20. | 1 |
  21. | 2 |
  22. | 3 |
  23. | 4 |
  24. +------+
  25. 4 rows in set (0.00 sec)

  26. B上:
  27. root@test 10:58>select @@tx_isolation;
  28. +------------------+
  29. | @@tx_isolation |
  30. +------------------+
  31. | READ-UNCOMMITTED |
  32. +------------------+
  33. 1 row in set (0.00 sec)

  34. root@test 10:58>
  35. root@test 10:58>begin;
  36. Query OK, 0 rows affected (0.00 sec)

  37. root@test 10:58>insert into test.test1 values (999);
  38. Query OK, 1 row affected (0.00 sec)

  39. root@test 10:58>select * from test.test1;
  40. +------+
  41. | a |
  42. +------+
  43. | 1 |
  44. | 2 |
  45. | 3 |
  46. | 4 |
  47. | 999 |
  48. +------+
  49. 5 rows in set (0.00 sec)
  50. 此处B客户端并未commit;

  51. 再查看A客户端:
  52. root@test 10:58>select * from test1;
  53. +------+
  54. | a |
  55. +------+
  56. | 1 |
  57. | 2 |
  58. | 3 |
  59. | 4 |
  60. | 999 |
  61. +------+
  62. 5 rows in set (0.00 sec)

  63. 此处A可以看到新的记录了。

Read Committed(读取提交内容)

       这是大多数数据库系统的默认隔离级别(但不是MySQL默认的)。它满足了隔离的简单定义:一个事务只能看见已经提交事务所做的改变。这种隔离级别 也支持所谓的不可重复读(Nonrepeatable Read),因为同一事务的其他实例在该实例处理其间可能会有新的commit,所以同一select可能返回不同结果。


点击(此处)折叠或打开

  1. 在A客户端:
  2. root@(none) 11:10>SET GLOBAL tx_isolation='READ-COMMITTED';
  3. Query OK, 0 rows affected (0.00 sec)

  4. root@(none) 11:10>SELECT @@tx_isolation;
  5. +----------------+
  6. | @@tx_isolation |
  7. +----------------+
  8. | READ-COMMITTED |
  9. +----------------+
  10. 1 row in set (0.00 sec)

  11. root@(none) 11:10>
  12. root@(none) 11:10>begin;
  13. Query OK, 0 rows affected (0.00 sec)

  14. root@(none) 11:10>select * from test.test1;
  15. +------+
  16. | a |
  17. +------+
  18. | 1 |
  19. | 2 |
  20. | 3 |
  21. | 4 |
  22. +------+

  23. 在B客户端执行:
  24. root@test 11:11>begin;
  25. Query OK, 0 rows affected (0.00 sec)

  26. root@test 11:11>select * from test.test1;
  27. +------+
  28. | a |
  29. +------+
  30. | 1 |
  31. | 2 |
  32. | 3 |
  33. | 4 |
  34. +------+
  35. 4 rows in set (0.00 sec)

  36. root@test 11:11>
  37. root@test 11:11>delete from test.test1 where a=1;
  38. Query OK, 1 row affected (0.00 sec)

  39. root@test 11:12>select * from test.test1;
  40. +------+
  41. | a |
  42. +------+
  43. | 2 |
  44. | 3 |
  45. | 4 |
  46. +------+

  47. 此时查询A客户端:

  48. root@(none) 11:12>select * from test.test1;
  49. +------+
  50. | a |
  51. +------+
  52. | 1 |
  53. | 2 |
  54. | 3 |
  55. | 4 |
  56. +------+
  57. 此处看出A客户端无变化,在B客户端执行commit后再查看A客户端:

  58. root@(none) 11:13>select * from test.test1;
  59. +------+
  60. | a |
  61. +------+
  62. | 2 |
  63. | 3 |
  64. | 4 |
  65. +------+

  66. 可以看到A客户端的数据已经变了。已提交读只允许读取已提交的记录,但不要求可重复读。
  67. 用MVCC来说就是读取当前行的最新版本。

Repeatable Read(可重读)

       这是MySQL的默认事务隔离级别,它确保同一事务的多个实例在并发读取数据时,会看到同样的数据行。不过理论上,这会导致另一个棘手的问题:幻读 (Phantom Read)。简单的说,幻读指当用户读取某一范围的数据行时,另一个事务又在该范围内插入了新行,当用户再读取该范围的数据行时,会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制(MVCC,Multiversion Concurrency Control)机制解决了该问题。


点击(此处)折叠或打开

  1. 在A客户端上:
  2. root@(none) 11:17>SET GLOBAL tx_isolation='REPEATABLE-READ';
  3. Query OK, 0 rows affected (0.00 sec)

  4. root@(none) 11:17>
  5. root@(none) 11:17>
  6. root@(none) 11:17>SELECT @@tx_isolation;
  7. +-----------------+
  8. | @@tx_isolation |
  9. +-----------------+
  10. | REPEATABLE-READ |
  11. +-----------------+
  12. 1 row in set (0.00 sec)

  13. root@(none) 11:17>BEGIN;
  14. Query OK, 0 rows affected (0.00 sec)

  15. 在B客户端上:
  16. root@test 11:20>select @@tx_isolation;
  17. +-----------------+
  18. | @@tx_isolation |
  19. +-----------------+
  20. | REPEATABLE-READ |
  21. +-----------------+
  22. 1 row in set (0.00 sec)

  23. root@test 11:20>insert into test.test1 values (555);
  24. Query OK, 1 row affected (0.00 sec)

  25. root@test 11:20>commit;
  26. Query OK, 0 rows affected (0.00 sec)

  27. root@test 11:21>
  28. root@test 11:21>select * from test.test1;
  29. +------+
  30. | a |
  31. +------+
  32. | 2 |
  33. | 3 |
  34. | 4 |
  35. | 555 |
  36. +------+
  37. 4 rows in set (0.00 sec)
  38. 此处在B客户端上已经commit.

  39. 然后查看A客户端:

  40. root@(none) 11:22>SELECT * FROM test.test1;
  41. +------+
  42. | a |
  43. +------+
  44. | 2 |
  45. | 3 |
  46. | 4 |
  47. +------+
  48. 3 rows in set (0.00 sec)

  49. root@(none) 11:22>commit;
  50. Query OK, 0 rows affected (0.00 sec)


  51. root@(none) 11:22>SELECT * FROM test.test1;
  52. +------+
  53. | a |
  54. +------+
  55. | 2 |
  56. | 3 |
  57. | 4 |
  58. | 555 |
  59. +------+
  60. 4 rows in set (0.00 sec)

  61. 在A客户端上提交后可以看到新数据。
  62. 也就是说在可重复读隔离级别只能读取已经提交的数据,并且在一个事务内,读取的数据就是事务开始时的数据。


Serializable(可串行化)
       这是最高的隔离级别,它通过强制事务排序,使之不可能相互冲突,从而解决幻读问题。简言之,它是在每个读的数据行上加上共享锁。在这个级别,可能导致大量的超时现象和锁竞争。

      该类型在A客户端操作test.test1表时会锁定该数据,如果B客户端想要操作test.test1就需要等待A客户端释放。









阅读(8191) | 评论(0) | 转发(0) |
1

上一篇:mysql 启动错误

下一篇:yum 报错

给主人留下些什么吧!~~