隔离性（Isolation）：同一时间，只允许一个事务请求同一数据，不同的事务之间彼此没有任何干扰。比如A正在从一张银行卡中取钱，在A取钱的过程结束前，B不能向这张卡转账。

不可重复读和幻读问题是指当事务不是独立执行时发生的一种现象。

不可重复读问题
不可重复读，是指在数据库访问中，一个事务范围内两个相同的查询却返回了不同数据。
这是由于查询时系统中其他事务修改的提交而引起的。
比如事务T1读取某一数据，事务T2读取并修改了该数据，T1为了对读取值进行检验而再次读取该数据
，便得到了不同的结果,称为不可重复读，即原始读取不可重复。

幻读的问题
事务A读取与搜索条件相匹配的若干行。事务B以插入或删除行等方式来修改事务A的结果集，然后再提交。
幻读是指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，比如这种修改涉及到表中的“全部数据行”。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入“一行新数据”。那么，以后就会发生操作第一个事务的用户发现表中还存在没有修改的数据行，就好象发生了幻觉一样.一般解决幻读的方法是增加范围锁RangeS，锁定检索范围为只读，这样就避免了幻读。

**二、事务的并发问题
　　1、脏读：事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据
　　2、不可重复读：事务 A 多次读取同一数据，事务 B 在事务A多次读取的过程中，对数据作了更新并提交，导致事务A多次读取同一数据时，结果 不一致。
　　3、幻读：系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级，但是系统管理员B就在这个时候插入了一条具体分数的记录，当系统管理员A改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。
　　小结：不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表

上文说的，是使用悲观锁机制来处理这两种问题，但是MySQL、ORACLE、PostgreSQL等成熟的数据库，出于性能考虑，都是使用了以乐观锁为理论基础的MVCC（多版本并发控制）来避免这两种问题。

  • 悲观锁

正如其名，它指的是对数据被外界（包括本系统当前的其他事务，以及来自外部系统的事务处理）修改持保守态度，因此，在整个数据处理过程中，将数据处 于锁定状态。悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机 制，也无法保证外部系统不会修改数据）。
在悲观锁的情况下，为了保证事务的隔离性，就需要一致性锁定读。读取数据时给加锁，其它事务无法修改这些数据。修改删除数据时也要加锁，其它事务无法读取这些数据。

  • 乐观锁

相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受。
而乐观锁机制在一定程度上解决了这个问题。乐观锁，大多是基于数据版本（ Version ）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个 “version” 字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如 果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。
要说明的是，MVCC的实现没有固定的规范，每个数据库都会有不同的实现方式，这里讨论的是InnoDB的MVCC。

三、MySQL事务隔离级别

事务隔离级别 脏读 不可重复读 幻读
读未提交（read-uncommitted） 是 是 是
不可重复读（read-committed） 否 是 是
可重复读（repeatable-read） 否 否 是
串行化（serializable） 否 否 否

mysql默认的事务隔离级别为repeatable-read

Mysql 的脏，幻，不可重复读 - 图1

读未提交

  1. ## 1）打开一个客户端A，并设置当前事务模式为read uncommitted（未提交读），查询表account的初始值：
  2. set session transaction isolation level read uncomitted;
  3. start transaction;
  4. select * from account;
  5. +-------+---------+---------+
  6. | id    | Name    | balance |
  7. +-------+---------+---------+
  8. | 1     | lilei   | 450     |
  9. | 2     | hanmei  | 16000   |
  10. | 3     | lucy    | 2400    |
  11. +-------+---------+---------+
  13. ## 2）打开另一个客户端B，更新表account：
  14. set session transaction isolation level read uncomitted;
  15. start transaction;
  16. update account set balance = balance - 50 where id = 1;
  17. select * from account;
  18. +-------+---------+---------+
  19. | id    | Name    | balance |
  20. +-------+---------+---------+
  21. | 1     | lilei   | 400     |
  22. | 2     | hanmei  | 16000   |
  23. | 3     | lucy    | 2400    |
  24. +-------+---------+---------+
  26. ## 3）这时，虽然客户端B的事务还没提交，但是客户端A就可以查询到B已经更新的数据：
  28. +-------+---------+---------+
  29. | id    | Name    | balance |
  30. +-------+---------+---------+
  31. | 1     | lilei   | 400     |
  32. | 2     | hanmei  | 16000   |
  33. | 3     | lucy    | 2400    |
  34. +-------+---------+---------+
  36. ## 4）一旦客户端B的事务因为某种原因回滚，所有的操作都将会被撤销，那客户端A查询到的数据其实就是脏数据
  37. ## 5）在客户端A执行更新语句update account set balance = balance - 50 where id =1
  38. ，lilei的balance没有变成350，居然是400，是不是很奇怪，数据不一致啊，如果你这么想就太天真 了
  39. ，在应用程序中，我们会用400-50=350，并不知道其他会话回滚了，要想解决这个问题可以采用读已提交的隔离级别

读已提交

  1. ## 1）打开一个客户端A
  2. set session transaction isolation level read committed;
  3. start transaction;
  4. select * from account;
  5. +-------+---------+---------+
  6. | id    | Name    | balance |
  7. +-------+---------+---------+
  8. | 1     | lilei   | 450     |
  9. | 2     | hanmei  | 16000   |
  10. | 3     | lucy    | 2400    |
  11. +-------+---------+---------+
  13. ## 2）打开另一个客户端B，更新表account：
  14. set session transaction isolation level read uncomitted;
  15. start transaction;
  16. update account set balance = balance - 50 where id = 1;
  17. select * from account;
  18. +-------+---------+---------+
  19. | id    | Name    | balance |
  20. +-------+---------+---------+
  21. | 1     | lilei   | 400     |
  22. | 2     | hanmei  | 16000   |
  23. | 3     | lucy    | 2400    |
  24. +-------+---------+---------+
  26. ## 3）这时，客户端B的事务还没提交，客户端A不能查询到B已经更新的数据，解决了脏读问题：
  27. select * from account;
  28. +-------+---------+---------+
  29. | id    | Name    | balance |
  30. +-------+---------+---------+
  31. | 1     | lilei   | 450     |
  32. | 2     | hanmei  | 16000   |
  33. | 3     | lucy    | 2400    |
  34. +-------+---------+---------+
  35. ## 4）客户端B的事务提交
  36. commit;
  38. ## 5）客户端A执行与上一步相同的查询，结果 与上一步不一致，即产生了不可重复读的问题
  39. select * from account;
  40. +-------+---------+---------+
  41. | id    | Name    | balance |
  42. +-------+---------+---------+
  43. | 1     | lilei   | 450     |
  44. | 2     | hanmei  | 16000   |
  45. | 3     | lucy    | 2400    |
  46. +-------+---------+---------+
  47. select * from account;
  48. +-------+---------+---------+
  49. | id    | Name    | balance |
  50. +-------+---------+---------+
  51. | 1     | lilei   | 400     |
  52. | 2     | hanmei  | 16000   |
  53. | 3     | lucy    | 2400    |
  54. +-------+---------+---------+

可重复读 — Mysql默认

  1. ## 1）打开一个客户端A
  2. set session transaction isolation level repeatable read;
  3. start transaction;
  4. select * from account;
  5. +-------+---------+---------+
  6. | id    | Name    | balance |
  7. +-------+---------+---------+
  8. | 1     | lilei   | 400     |
  9. | 2     | hanmei  | 16000   |
  10. | 3     | lucy    | 2400    |
  11. +-------+---------+---------+
  13. ## 2) 打开另一个客户端B，更新表account：
  14. set session transaction isolation level read uncomitted;
  15. start transaction;
  16. update account set balance = balance - 50 where id = 1;
  17. select * from account;
  18. +-------+---------+---------+
  19. | id    | Name    | balance |
  20. +-------+---------+---------+
  21. | 1     | lilei   | 350     |
  22. | 2     | hanmei  | 16000   |
  23. | 3     | lucy    | 2400    |
  24. +-------+---------+---------+
  25. commit;
  27. ## 3）在客户端A查询表account的所有记录，与步骤（1）查询结果一致，没有出现不可重复读的问题
  28. ## 4）在客户端A，接着执行update balance = balance - 50 where id = 1，
  29. balance没有变成400-50=350，lilei的balance值用的是步骤（2）中的350来算的，
  30. 所以是300，数据的一致性倒是没有被破坏。可重复读的隔离级别下使用了MVCC机制，
  31. select操作不会更新版本号，是快照读（历史版本）；
  32. insert、update和delete会更新版本号，是当前读（当前版本）。
  34. select * from account;
  35. +-------+---------+---------+
  36. | id    | Name    | balance |
  37. +-------+---------+---------+
  38. | 1     | lilei   | 400     |
  39. | 2     | hanmei  | 16000   |
  40. | 3     | lucy    | 2400    |
  41. +-------+---------+---------+
  42. update account set balance = balance - 50 where id = 1;
  43. select * from account;
  44. +-------+---------+---------+
  45. | id    | Name    | balance |
  46. +-------+---------+---------+
  47. | 1     | lilei   | 300     |
  48. | 2     | hanmei  | 16000   |
  49. | 3     | lucy    | 2400    |
  50. +-------+---------+---------+
  52. ## 5) 重新打开客户端B，插入一条新数据后提交
  53. start transaction;
  54. insert into account values(4, 'lily', 700);
  55. commit;
  56. ## 6）在客户端A查询表account的所有记录，没有 查出 新增数据，所以没有出现幻读
  57. select * from account;
  58. +-------+---------+---------+
  59. | id    | Name    | balance |
  60. +-------+---------+---------+
  61. | 1     | lilei   | 300     |
  62. | 2     | hanmei  | 16000   |
  63. | 3     | lucy    | 2400    |
  64. +-------+---------+---------+

串行化

  1. ## 1）打开一个客户端A，并设置当前事务模式为serializable，查询表account的初始值
  2. set session transaction isolation level serializable;
  3. start transaction;
  4. select * from account;
  5. +------+--------+---------+
  6. | id   | name   | balance |
  7. +------+--------+---------+
  8. |    1 | lilei  |   10000 |
  9. |    2 | hanmei |   10000 |
  10. |    3 | lucy   |   10000 |
  11. |    4 | lily   |   10000 |
  12. +------+--------+---------+
  13. ## 2）打开一个客户端B，并设置当前事务模式为serializable，插入一条记录报错，表被锁了插入失败
  14. ，mysql中事务隔离级别为serializable时会锁表
  15. ，因此不会出现幻读的情况，这种隔离级别并发性极低，开发中很少会用到。
  17. set session transaction isolation level serializable;
  18. start transaction;
  19. insert into account values(5,'tom',0);
  20. ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

1、事务隔离级别为读提交时，写数据只会锁住相应的行
　　2、事务隔离级别为可重复读时，如果检索条件有索引（包括主键索引）的时候，默认加锁方式是next-key 锁；如果检索条件没有索引，更新数据时会锁住整张表。一个间隙被事务加了锁，其他事务是不能在这个间隙插入记录的，这样可以防止幻读。
　　3、事务隔离级别为串行化时，读写数据都会锁住整张表
　　 4、隔离级别越高，越能保证数据的完整性和一致性，但是对并发性能的影响也越大。
　　 5、MYSQL MVCC实现机制参考链接：https://blog.csdn.net/whoamiyang/article/details/51901888
　　 6、关于next-key 锁可以参考链接：https://blog.csdn.net/bigtree_3721/article/details/73731377