事务
MySQL有众多引擎, 比如常用的InnoDB, MyISAM, MEMORY等, 但是只有InnoDB支持事务.因此, 本文所有的叙述以及操作, 都是建立在InnoDB的基础上.
什么是事务?
首先事务多用来管理一组SQL, 保证这一组SQL要么都成功, 要么都失败.
事务的相关操作
begin; -- 开启事务
commit; -- 提交事务
rollback; -- 回滚事务
savepoint xxx; -- 设置保存点, 可以用于回滚
release savepoint xxx; -- 删除事务中的某个保存点, 没有保存点会报错
rollback to xxx; -- 回滚到某个保存点
SET [SESSION | GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE} ; --设置隔离级别
比如A向B转账100块, 那就有两个sql
set AUTOCOMMIT = 0;
begin;
update money set amount = amount + 100 where name = 'B';
update money set amount = amount - 100 where name = 'A';
commit;
set AUTOCOMMIT = 1;
如果成功一条, 另一条失败了, 那就出大问题.
事务具有4个特性
事务必须要满足下面4个特性, 也就是常说的ACID
- 原子性(Atomicity)
一组sql要么都成功, 要么都失败, 如果在执行的过程有一条SQL执行事变了, 则会进行回滚(rollback) - 一致性(Consistency)
在事务执行前后, 数据的整体性不会被破坏.
比如上面的例子, 假设A有520块钱, B有20块钱, A转给B100块, 最终A有420块, B有120块. 不管是转账前还是转账后, 两个人的总额依旧是540块钱. - 隔离性
指多个事务之前相互隔离, 一个事务的操作不会影响到另一个事务.隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致.
四种隔离级别: 读未提交(Read Uncommited), 读已提交(Read Commited), 可重复读(Repeatable Read), 串行化(Serializable)
后面会将每种隔离级别的区别以及带来的问题. - 持久性
事务一旦提交, 就会持久化到磁盘, 不会因为系统崩溃, 机房断电等因袭而影响结果.
隔离级别
MySQL一共有四种隔离级别, 分别是读未提交, 读已提交, 可重复读, 串行化
读未提交
首先是读未提交(Read Uncommited) 级别, 顾名思义, 这一级别可以读到其他事务未提交的数据. 如果使用这一隔离级别, 前一秒查询money.amount是20, 后一秒money.amount就变成了120, 这一现象也就是脏读, 侧重于insert和update操作.
脏读
读到本不应该读到的数据. 也就是读到了还未提交的数据.
时序图:
读未提交.png
模拟:
首先修改隔离级别, 然后重启客户端
set global transaction isolation level reda uncommited;
测试数据actor表共三条数据
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | d | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
打开两个客户端:
事务1: 开启事务
需要关闭自动提交, 测试完毕后需要重新开启
mysql> set autocommit = 0;
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
事务2: 开启事务
mysql> set autocommit = 0;
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | d | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
事务2: 执行更新
mysql> update actor set name = 'a' where id = 1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
事务1: 再次执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | a | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
此时, 事务1已经读到事务2未提交的数据.
事务2: 回滚数据
mysql> rollback;
mysql> set autocommit = 1;
Query OK, 0 rows affected (0.01 sec)
事务1: 再次执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | d | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
事务1: 提交事务
mysql> commit;
mysql> set autocommit = 1;
Query OK, 0 rows affected (0.00 sec)
读已提交
读已提交只能读到已提交的事务的数据. 解决了脏读的问题.
时序图:
读已提交.png
模拟:
首先修改隔离级别
set global transaction isolation level read commited;
开启两个客户端
事务1: 开启事务
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
事务2: 开启事务
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | d | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
事务2: 执行更新
mysql> update actor set name = 'a' where id = 1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | d | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.01 sec)
事务2: 提交事务
mysql> commit;
Query OK, 0 rows affected (0.00 sec)
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | a | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
事务1: 提交事务
mysql> commit;
Query OK, 0 rows affected (0.00 sec)
可重复读
读已提交解决了脏读的问题, 却产生了另一个问题: 不可重复读
不可重复读
一个事务内, 两次读到的数据不一致.
比如读已提交级别的模拟, 事务1的第二次查和第三次查询的结果不一致, 为了让事务1的2,3两次查询数据一致, 引入了可重复读隔离级别
时序图
可重复读.png
模拟:
首先还是得修改隔离级别
set global transaction isolation level repeatable read;
然后, 开启两个客户端
事务1: 开启事务
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
事务2: 开启事务
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | a | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
事务2: 执行更新
mysql> update actor set name = 'r' where id = 1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | a | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
事务2: 提交事务
mysql> commit;
Query OK, 0 rows affected (0.00 sec)
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | a | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
事务2: 开启事务, 并插入一条数据
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into actor values(4, 'e', now());
Query OK, 1 row affected (0.01 sec)
mysql> commit;
Query OK, 0 rows affected (0.00 sec)
事务1: 执行查询
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | a | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
+----+------+---------------------+
3 rows in set (0.00 sec)
此时, 发现依旧没有新增的那条数据, 难道可重复读解决了幻读的问题? 接下来, 我们执行下面这一sql
事务1: 更新数据
mysql> update actor set name = 'f' where id = 4;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1 Changed: 1 Warnings: 0
发现记录更新成功, 说明可重复读, 可以解决查询的幻读问题, 但是不能解决更新的幻读问题
幻读(更新)
事务1: 查询数据
mysql> select * from actor;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | a | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
| 4 | f | 2021-06-02 21:00:39 |
+----+------+---------------------+
4 rows in set (0.00 sec)
事务1: 提交事务
mysql> commit;
Query OK, 0 rows affected (0.01 sec)
在事务1中, 可以通过加锁的方式查询到新增的数据.
-- 事务2: 插入1条新数据
mysql> begin;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into actor values(5, 'h', now());
Query OK, 1 row affected (0.01 sec)
mysql> commit;
Query OK, 0 rows affected (0.00 sec)
-- 事务1:
mysql> select * from actor for update;
+----+------+---------------------+
| id | name | update_time |
+----+------+---------------------+
| 1 | d | 2021-05-29 20:53:53 |
| 2 | b | 2021-05-29 20:53:53 |
| 3 | c | 2021-05-29 20:53:53 |
| 4 | f | 2021-06-02 21:00:39 |
| 5 | h | 2021-06-02 21:09:36 |
+----+------+---------------------+
5 rows in set (14.39 sec)
锁
MySQL的锁从类型上可以分为悲观锁和乐观锁, 从锁的粒度上可以分为行锁, 表锁, 间隙锁. 从行为上可以分为排它锁和共享锁
悲观锁
顾名思义, 就是很悲观, 认为肯定会有人和他竞争, 所以不管有没有竞争直接加锁.
乐观锁
很乐观, 任务不会有人和他竞争, 也就不用加锁, 一般的实现方案是版本号. 每次更新前, 要先查出当前的版本号, 然后在更新的时候将版本号作为更新的条件.
update actor set name = '张三' where id = 1 and version = 2;
排它锁
共享锁
表锁
表锁有加锁开销小, 速度快, 不容易死锁等特点, 这也容易理解, 直接给整张表加锁, 粒度是相当的粗了. 其他事务也很容易判断表是不是有锁, 也就不容易造成死锁.
表锁分为读锁和写锁
读锁
lock tables t1 read; -- 加锁
select * from t1; -- 正常查询
select * from t2; -- 查询报错 Table 't2' was not locked with LOCK TABLES
unlock tables; -- 释放锁
写锁
lock tables actor WRITE;
insert into actor(id, name, update_time) VALUES(21,'zhansan', now());
insert into film(id, name) values(4, 'test');
UNLOCK TABLES;
行锁
行锁具有开销大, 加锁速度慢, 容易出现死锁等现象.发生锁冲突的概率低, 并发度高. 行锁只锁住某几行, 不会影响其他行的操作, 在操作其他行时, 可以不用等待, 提高并发量.
select for update; // 排它锁
select lock in share mode;// 共享锁