本文实验的测试环境: Windows 10+cmd+MySQL5.6.36+InnoDB
一, 事务的基本要素(ACID)
1, 原子性(Atomicity): 事务开始后所有操作, 要么全部做完, 要么全部不做, 不可能停滞在中间环节. 事务执行过程中出错, 会回滚到事务开始前的状态, 所有的操作就像没有发生一样. 也就是说事务是一个不可分割的整体, 就像化学中学过的原子, 是物质构成的基本单位.
2, 一致性(Consistency): 事务开始前和结束后, 数据库的完整性约束没有被破坏 . 比如 A 向 B 转账, 不可能 A 扣了钱, B 却没收到.
3, 隔离性(Isolation): 同一时间, 只允许一个事务请求同一数据, 不同的事务之间彼此没有任何干扰. 比如 A 正在从一张银行卡中取钱, 在 A 取钱的过程结束前, B 不能向这张卡转账.
4, 持久性(Durability): 事务完成后, 事务对数据库的所有更新将被保存到数据库, 不能回滚.
二, 事务的并发问题
1, 脏读: 事务 A 读取了事务 B 更新的数据, 然后 B 回滚操作, 那么 A 读取到的数据是脏数据
2, 不可重复读: 事务 A 多次读取同一数据, 事务 B 在事务 A 多次读取的过程中, 对数据作了更新并提交, 导致事务 A 多次读取同一数据时, 结果 不一致.
3, 幻读: 系统管理员 A 将数据库中所有学生的成绩从具体分数改为 ABCDE 等级, 但是系统管理员 B 就在这个时候插入了一条具体分数的记录, 当系统管理员 A 改结束后发现还有一条记录没有改过来, 就好像发生了幻觉一样, 这就叫幻读.
小结: 不可重复读的和幻读很容易混淆, 不可重复读侧重于修改, 幻读侧重于新增或删除. 解决不可重复读的问题只需锁住满足条件的行, 解决幻读需要锁表
三, MySQL 事务隔离级别
事务隔离级别 | 脏读 | 不可重复读 | 幻读 |
读未提交(read-uncommitted) | 是 | 是 | 是 |
不可重复读(read-committed) | 否 | 是 | 是 |
可重复读(repeatable-read) | 否 | 否 | 是 |
串行化(serializable) | 否 | 否 | 否 |
mysql 默认的事务隔离级别为 repeatable-read
四, 用例子说明各个隔离级别的情况
1, 读未提交:
(1)打开一个客户端 A, 并设置当前事务模式为 read uncommitted(未提交读), 查询表 account 的初始值:
(2)在客户端 A 的事务提交之前, 打开另一个客户端 B, 更新表 account:
(3)这时, 虽然客户端 B 的事务还没提交, 但是客户端 A 就可以查询到 B 已经更新的数据:
(4)一旦客户端 B 的事务因为某种原因回滚, 所有的操作都将会被撤销, 那客户端 A 查询到的数据其实就是脏数据:
(5)在客户端 A 执行更新语句 update account set balance = balance - 50 where id =1,lilei 的 balance 没有变成 350, 居然是 400, 是不是很奇怪, 数据不一致啊, 如果你这么想就太天真 了, 在应用程序中, 我们会用 400-50=350, 并不知道其他会话回滚了, 要想解决这个问题可以采用读已提交的隔离级别
2, 读已提交
(1)打开一个客户端 A, 并设置当前事务模式为 read committed(未提交读), 查询表 account 的初始值:
(2)在客户端 A 的事务提交之前, 打开另一个客户端 B, 更新表 account:
(3)这时, 客户端 B 的事务还没提交, 客户端 A 不能查询到 B 已经更新的数据, 解决了脏读问题:
(4)客户端 B 的事务提交
(5)客户端 A 执行与上一步相同的查询, 结果 与上一步不一致, 即产生了不可重复读的问题
3, 可重复读
(1)打开一个客户端 A, 并设置当前事务模式为 repeatable read, 查询表 account
(2)在客户端 A 的事务提交之前, 打开另一个客户端 B, 更新表 account 并提交
(3)在客户端 A 执行步骤 (1) 的查询:
(4)执行步骤 (1),lilei 的 balance 仍然是 400 与步骤(1) 查询结果一致, 没有出现不可重复读的 问题; 接着执行 update balance = balance - 50 where id = 1,balance 没有变成 400-50=350,lilei 的 balance 值用的是步骤 (2) 中的 350 来算的, 所以是 300, 数据的一致性倒是没有被破坏, 这个有点神奇, 也许是 mysql 的特色吧
- mysql> select * from account;
- +------+--------+---------+
- | id | name | balance |
- +------+--------+---------+
- | 1 | lilei | 400 |
- | 2 | hanmei | 16000 |
- | 3 | lucy | 2400 |
- +------+--------+---------+
- 3 rows in set (0.00 sec)
- mysql> update account set balance = balance - 50 where id = 1;
- Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
- mysql> select * from account;
- +------+--------+---------+
- | id | name | balance |
- +------+--------+---------+
- | 1 | lilei | 300 |
- | 2 | hanmei | 16000 |
- | 3 | lucy | 2400 |
- +------+--------+---------+
- 3 rows in set (0.00 sec)
(5) 在客户端 A 提交事务, 查询表 account 的初始值
- mysql> commit;
- Query OK, 0 rows affected (0.00 sec)
- mysql> select * from account;
- +------+--------+---------+
- | id | name | balance |
- +------+--------+---------+
- | 1 | lilei | 300 |
- | 2 | hanmei | 16000 |
- | 3 | lucy | 2400 |
- +------+--------+---------+
- 3 rows in set (0.00 sec)
(6)在客户端 B 开启事务, 新增一条数据, 其中 balance 字段值为 600, 并提交
- mysql> start transaction;
- Query OK, 0 rows affected (0.00 sec)
- mysql> insert into account values(4,'lily',600);
- Query OK, 1 row affected (0.00 sec)
- mysql> commit;
- Query OK, 0 rows affected (0.01 sec)
(7) 在客户端 A 计算 balance 之和, 值为 300+16000+2400=18700, 没有把客户端 B 的值算进去, 客户端 A 提交后再计算 balance 之和, 居然变成了 19300, 这是因为把客户端 B 的 600 算进去了
, 站在客户的角度, 客户是看不到客户端 B 的, 它会觉得是天下掉馅饼了, 多了 600 块, 这就是幻读, 站在开发者的角度, 数据的 一致性并没有破坏. 但是在应用程序中, 我们得代码可能会把 18700 提交给用户了, 如果你一定要避免这情况小概率状况的发生, 那么就要采取下面要介绍的事务隔离级别 "串行化"
- mysql> select sum(balance) from account;
- +--------------+
- | sum(balance) |
- +--------------+
- | 18700 |
- +--------------+
- 1 row in set (0.00 sec)
- mysql> commit;
- Query OK, 0 rows affected (0.00 sec)
- mysql> select sum(balance) from account;
- +--------------+
- | sum(balance) |
- +--------------+
- | 19300 |
- +--------------+
- 1 row in set (0.00 sec)
4. 串行化
(1)打开一个客户端 A, 并设置当前事务模式为 serializable, 查询表 account 的初始值:
- mysql> set session transaction isolation level serializable;
- Query OK, 0 rows affected (0.00 sec)
- mysql> start transaction;
- Query OK, 0 rows affected (0.00 sec)
- mysql> select * from account;
- +------+--------+---------+
- | id | name | balance |
- +------+--------+---------+
- | 1 | lilei | 10000 |
- | 2 | hanmei | 10000 |
- | 3 | lucy | 10000 |
- | 4 | lily | 10000 |
- +------+--------+---------+
- 4 rows in set (0.00 sec)
(2)打开一个客户端 B, 并设置当前事务模式为 serializable, 插入一条记录报错, 表被锁了插入失败, mysql 中事务隔离级别为 serializable 时会锁表, 因此不会出现幻读的情况, 这种隔离级别并发性极低, 开发中很少会用到.
- mysql> set session transaction isolation level serializable;
- Query OK, 0 rows affected (0.00 sec)
- mysql> start transaction;
- Query OK, 0 rows affected (0.00 sec)
- mysql> insert into account values(5,'tom',0);
- ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
补充:
1,SQL 规范所规定的标准, 不同的数据库具体的实现可能会有些差异
2,mysql 中默认事务隔离级别是可重复读时并不会锁住读取到的行
3, 事务隔离级别为读提交时, 写数据只会锁住相应的行
4, 事务隔离级别为可重复读时, 如果有索引 (包括主键索引) 的时候, 以索引列为条件更新数据, 会存在间隙锁间隙锁, 行锁, 下一键锁的问题, 从而锁住一些行; 如果没有索引, 更新数据时会锁住整张表.
5, 事务隔离级别为串行化时, 读写数据都会锁住整张表
6, 隔离级别越高, 越能保证数据的完整性和一致性, 但是对并发性能的影响也越大, 鱼和熊掌不可兼得啊. 对于多数应用程序, 可以优先考虑把数据库系统的隔离级别设为 Read Committed, 它能够避免脏读取, 而且具有较好的并发性能. 尽管它会导致不可重复读, 幻读这些并发问题, 在可能出现这类问题的个别场合, 可以由应用程序采用悲观锁或乐观锁来控制.
来源: http://www.92to.com/bangong/2018/04-26/33674661.html