mysql 事务_MySQL事务

MySQL中，事务其实是一个最小的，不可分割的工作单元，事务能够保证一个业务的完整性。

比如：我们的银行转账：a给b转账100

a---->-100

b---->+100

update user set money=money-100 where name='a';

update user set money=money+100 where name='b';

实际的程序中，如果只有一条语句执行成功了，而另外一条没有成功，就会出现数据前后不一致的情况。

这时候就是事务大显神通的地方了：

MySQL中如何控制事务？

1.MySQL默认是开启自动提交的

MySQL 默认情况下开启了一个自动提交的模式 autocommit，一条语句被回车执行后该语句便生效了，便会保存在 MySQL 的文件中，无法撤消。

mysql

默认开启自动提交的作用是什么？

当我们去执行一个SQL语句的时候，效果会立即体现出来，且不能回滚。

mysql> create database bank;
Query OK, 1 row affected (0.01 sec)mysql> use bank;
Database changedmysql> create table user(id int primary key,name varchar(20),money int);
Query OK, 0 rows affected (0.35 sec)mysql> insert into user values(1,'a',1000);
Query OK, 1 row affected (0.14 sec)mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
+----+------+-------+
1 row in set (0.00 sec)

事务回滚 : 撤销SQL语句执行效果

rollback;

mysql> rollback;
Query OK, 0 rows affected (0.11 sec)mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
+----+------+-------+
1 row in set (0.00 sec)

我们发现，执行完回滚后，user表没有回到插入数据之前的状态，这是因为（MySQL默认是开启自动提交的），一旦执行，是自动提交的，所以我们如果想要回到插入数据之前的状态（回滚）就需要设置MySQL自动提交为False：

这也是开启事务的一种方式：

set autocommit=0;

mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)mysql> select @@autocommit;
+--------------+
| @@autocommit |
+--------------+
|            0 |
+--------------+
1 row in set (0.00 sec)

上面的操作，关闭了MySQL的自动提交（autocommit）

mysql> insert into user values(2,'b',1000);
Query OK, 1 row affected (0.01 sec)mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)
--我们这时候看到的数据，实际上是一个临时表中的数据
--我们关闭了autocommit，这时候回滚就生效了
mysql> rollback;
Query OK, 0 rows affected (0.14 sec)mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
+----+------+-------+
1 row in set (0.00 sec)

--再一次插入数据
mysql> insert into user values(2,'b',1000);
Query OK, 1 row affected (0.15 sec)
--手动提交数据
mysql> commit;
Query OK, 0 rows affected (0.04 sec)
--再撤销，就不管用了（体现了事务的持久性，事务一旦提交，就不能回滚了，也就是当前的这个事务在提交的时候就结束了）
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

如果说这个时候转账（此时autocommit处于关闭状态）：a给b转账100

update user set money=money-100 where name='a';

update user set money=money+100 where name='b';

mysql> update user set money=money-100 where name='a';
Query OK, 1 row affected (0.11 sec)
Rows matched: 1  Changed: 1  Warnings: 0mysql> update user set money=money+100 where name='b';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1100 |
+----+------+-------+
2 rows in set (0.00 sec)mysql> rollback;
Query OK, 0 rows affected (0.14 sec)mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

--在进行接下来的操作前，我们修改自动提交为开启状态。（回滚事务失效）
mysql> set autocommit=1;
Query OK, 0 rows affected (0.00 sec)mysql> select @@autocommit;
+--------------+
| @@autocommit |
+--------------+
|            1 |
+--------------+
1 row in set (0.00 sec)

2.手动开启一个事务

begin;或者start transaction;

通过begin;或者start transaction;显式声明开始一个事务，autocommit 默认会是关闭状态。

begin;

update user set money=money-100 where name='a';

update user set money=money+100 where name='b';

mysql> begin;
Query OK, 0 rows affected (0.00 sec)mysql>
mysql> update user set money=money-100 where name='a';
Query OK, 1 row affected (0.10 sec)
Rows matched: 1  Changed: 1  Warnings: 0mysql>
mysql> update user set money=money+100 where name='b';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |   900 |
|  2 | b    |  1100 |
+----+------+-------+
2 rows in set (0.00 sec)mysql> rollback;
Query OK, 0 rows affected (0.14 sec)mysql> select * from user;
+----+------+-------+
| id | name | money |
+----+------+-------+
|  1 | a    |  1000 |
|  2 | b    |  1000 |
+----+------+-------+
2 rows in set (0.00 sec)

事务给我们提供了一个返回的机会:回滚

总结：

关于 autocommit 与事务，它们其实是这样的关系：

1.MySQL 每一步操作都可看成一个原子操作。默认情况下，autocommit 是开启状态，所以每一条语句都是执行后自动提交，语句产生的效果会被记录保存下来（这时候回滚是无效的）。

2.我们手动关闭autocommit 后，语句不会自动提交，这时需要手动调用 COMMIT 来让效果被持久化。

3.在默认情况下，（autocommit 处于开启状态时）我们也可通过 BEGIN 开启一个事务，此时 autocommit 被隐式地关闭了，因此事务操作过程中也是需要显式调用 COMMIT 来让效果永久生效。

4.BEGIN 开启一个事务后，使用 COMMIT 或 ROLLBACK 来结束该事务。事务结束后，autocommit 回到原有的状态。所以，autocommit 这个开关相当于一个记录事务的标记，它被关闭时，你一直处于一个可回滚的状态。而 BEGIN 开启的是一次临时事务，一旦 COMMIT 或 ROLLBACK 本次事务便结束了。

3.事物的四大特征：

A.原子性：事务是最小的单位，不可再分割。

C.一致性：事务要求，同一事务中的SQL语句，要么同时成功，要么同时失败。

I.隔离性：事务1与事务2之间具有隔离性。

D.持久性：事务一旦结束（commit | rollback），就不可以返回。

4.开启事务：

1.set autocommit=0;

2.begin;

3.start transaction;

5.事务手动提交：

commit; (让虚拟的效果真实的产生)

6.事务手动回滚：

rollback; （让虚拟的效果被撤销了）

7.事物的隔离性

（1）read uncommitted; 读未提交的

（2）read committed; 读已经提交的

（3）repeatable read; 可以重复读

（4）serializable; 串行化

实例1：read uncommitted; 读未提交的

如果有事务a 和事务b,

a事务对数据进行操作，在操作过程中，事务没有被提交，但是b可以看见a操作的结果

bank 数据库 user表

insert into user values(3,'小明'，1000);

insert into user values(4,'淘宝店'，1000);

解决插入中文乱码的问题：（当然这样比较麻烦）

mysql> alter table user default character set utf8;
Query OK, 0 rows affected (0.05 sec)
Records: 0  Duplicates: 0  Warnings: 0mysql> show create table user;
+-------+----------------------------------------------------------------------+
| Table | Create Table                                                         |
+-------+----------------------------------------------------------------------+
| user  | CREATE TABLE `user` (`id` int(11) NOT NULL,`name` varchar(20) CHARACTER SET latin1 DEFAULT NULL,`money` int(11) DEFAULT NULL,PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 |
+-------+---------------------------------------------------------------------+
1 row in set (0.00 sec)mysql> alter table user change name name varchar(20) character set utf8;
Query OK, 2 rows affected (0.88 sec)
Records: 2  Duplicates: 0  Warnings: 0

我们可以在创建数据库的时候可以直接设置好编码，当然如果我们忘记了设置，导致出现乱码，我们依旧可以通过Navicat这个可视化操作数据库的工具在数据库属性中修改：

前提是数据库处于关闭状态，这样修改才能生效！

我们继续：

mysql> insert into user values(3,'小明',1000);
Query OK, 1 row affected (0.15 sec)mysql> insert into user values(4,'淘宝店',1000);
Query OK, 1 row affected (0.13 sec)mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
+----+--------+-------+
4 rows in set (0.00 sec)

如何查看数据库的隔离级别：

mysql 5.X select @@global.tx_isolation; 系统级别的

select @@tx_isolation; 会话级别的

mysql 8.0 select @@global.transaction_isolation; 系统级别的

select @@transaction_isolation; 会话级别的

mysql> select @@global.transaction_isolation;
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| REPEATABLE-READ                |
+--------------------------------+
1 row in set (0.00 sec)

如何修改数据库的隔离级别：

修改数据库的隔离级别为 read uncommitted

set global transaction isolation level read uncommitted;

mysql> set global transaction isolation level read uncommitted;
Query OK, 0 rows affected (0.10 sec)mysql> select @@global.transaction_isolation;
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| READ-UNCOMMITTED               |
+--------------------------------+
1 row in set (0.00 sec)

--例子：转账：小明在淘宝店买鞋子，鞋子800元。

小明---成都 ATM

淘宝店---广州 ATM

start transaction;

update user set money=money-800 where name='小明';

update user set money=money+800 where name='淘宝店';

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)mysql> update user set money=money-800 where name='小明';
Query OK, 1 row affected (0.02 sec)
Rows matched: 1  Changed: 1  Warnings: 0mysql> update user set money=money+800 where name='淘宝店';
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |   200 |
|  4 | 淘宝店 |  1800 |
+----+--------+-------+
4 rows in set (0.00 sec)

---小明给淘宝店打电话，说你去查一下，是不是到账了。

---淘宝店主在广州查账：（重新开启一个cmd窗口进行查询）

mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |   200 |
|  4 | 淘宝店 |  1800 |
+----+--------+-------+
4 rows in set (0.00 sec)

---发现钱到账了，于是发货

---淘宝店主，晚上请女朋友吃好吃的，花费1800

---小明成都 rollback;

mysql> rollback;
Query OK, 0 rows affected (0.05 sec)mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
+----+--------+-------+
4 rows in set (0.00 sec)

---淘宝店主去结账，发现钱不够，一查：

mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
+----+--------+-------+
4 rows in set (0.00 sec)

如果两个不同的地方都在进行操作，如果事务a开启之后，它的事务可以被其他事务读取到，这样就会出现脏读。（也就是这个例子中淘宝店主第一次查账时：读取到了小明未提交的事务的数据，导致误以为钱到账了）

脏读：一个事务读到了另外一个事务没有提交的数据，就叫做脏读。

实例2：read committed; 读已经提交的

修改数据库隔离级别： read committed

set global transaction isolation level read committed;

查看数据库隔离级别：

select @@global.transaction_isolation;

mysql> set global transaction isolation level read committed;
Query OK, 0 rows affected (0.00 sec)mysql> select @@global.transaction_isolation;
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| READ-COMMITTED                 |
+--------------------------------+
1 row in set (0.00 sec)

bank 数据库 user 表

小张：银行的会计

start transaction;

select * from user;

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
+----+--------+-------+
4 rows in set (0.00 sec)

小张出去上厕所去了。

小王：

start transaction;

insert into user values(5,'c',100);

commit;

mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)mysql> insert into user values(5,'c',100);
Query OK, 1 row affected (0.11 sec)mysql> commit;
Query OK, 0 rows affected (0.13 sec)mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
+----+--------+-------+
5 rows in set (0.00 sec)

小张上完厕所回来了

select avg(money) from user;

mysql> select avg(money) from user;
+------------+
| avg(money) |
+------------+
|   820.0000 |
+------------+
1 row in set (0.00 sec)

---money的平均值变少了，不是1000；

虽然我只能读到另外一个事务提交的数据，但还是会出现问题，就是读取同一个表的数据，发现前后不一致。

这就出现了不可重复读现象：（在read committed读取已经提交的这种隔离级别下发生）

注：这个隔离级别 read committed;读已经提交的解决了什么问题呢？

我们可以想想：它解决了实例1中的脏读问题，就是事务a读取不到另外一个事务未提交的数据的（这里就不演示了）。这里的不可重复读现象，是在另一个事务提交后读到的，只不过因为某种原因，他不知道罢了。

实例3：repeatable read; 可以重复读

修改数据库隔离级别： repeatable read

set global transaction isolation level repeatable read;

查看数据库隔离级别：

select @@global.transaction_isolation;

mysql> set global transaction isolation level repeatable read;
Query OK, 0 rows affected (0.00 sec)mysql> select @@global.transaction_isolation;
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| REPEATABLE-READ                |
+--------------------------------+
1 row in set (0.00 sec)

在REPEATABLE-READ 隔离级别下又会出现什么问题？

mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
+----+--------+-------+
5 rows in set (0.00 sec)

第一步：【注：两个不同的人操作，我们模拟是在两个不同的cmd窗口下模拟执行SQL】

--张全蛋成都

start transaction;

--王尼玛北京

start transaction;

第二步：

--张全蛋成都

insert into user values(6,'d',1000);

--王尼玛北京

此时，王尼玛并不知道张全蛋插入了一条数据，此时他查询

mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
+----+--------+-------+
5 rows in set (0.00 sec)

数据没有变。

这时张全蛋提交数据：张全蛋查询：

mysql> commit;
Query OK, 0 rows affected (0.13 sec)mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
|  6 | d      |  1000 |
+----+--------+-------+
6 rows in set (0.00 sec)

这时王尼玛依旧不知道：他查询数据：

mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
+----+--------+-------+
5 rows in set (0.00 sec)

依旧是没变的数据

从这里可以看出隔离级别：REPEATABLE-READ 解决了不可重复读的问题。

那么这里会出现什么问题呢？注意：

但是此时王尼玛插入数据报错：

mysql> insert into user values(6,'d',1000);
ERROR 1062 (23000): Duplicate entry '6' for key 'PRIMARY'

王尼玛他自己查询没有这条数据（实际上张全蛋已经插入了），所以他进行插入操作（插入和张全蛋插入的相同数据），但是却报错了，这就造成了幻读。

幻读：事务a和事务b同时操作一张表，事务提交的数据，不能被事务a读到，当事务a插入与事务b相同的数据时，就造成了幻读。

从这些例子可以看出四个隔离级别越来越高，到REPEATABLE-READ 隔离级别时：不同事务之间读取数据只能获取到自己的操作了，其他事务的操作（不管是未提交的还是已提交的）都读不到了。

实例4：serializable; 串行化

修改隔离级别为串行化：

set global transaction isolation level serializable;

查看隔离级别：

select @@global.transaction_isolation;

mysql> set global transaction isolation level  serializable;
Query OK, 0 rows affected (0.00 sec)mysql> select @@global.transaction_isolation;
+--------------------------------+
| @@global.transaction_isolation |
+--------------------------------+
| SERIALIZABLE                   |
+--------------------------------+
1 row in set (0.00 sec)

原始数据：

mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
|  6 | d      |  1000 |
+----+--------+-------+
6 rows in set (0.00 sec)

第一步：

--张全蛋成都

start transaction;

--王尼玛北京

start transaction;

第二步：

--张全蛋成都插入一条数据

mysql> insert into user values(7,'赵铁柱',1000);
Query OK, 1 row affected (0.16 sec)mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
|  6 | d      |  1000 |
|  7 | 赵铁柱 |  1000 |
+----+--------+-------+
7 rows in set (0.00 sec)

--王尼玛北京此时查询 SQL语句被卡住了？

mysql> select * from user;

--张全蛋成都此时张全蛋对刚刚插入的数据进行提交

mysql> commit;
Query OK, 0 rows affected (0.00 sec)

在张全蛋提交完以后，我们发现另一边，王尼玛的（刚刚卡住的）查询语句执行了

mysql> select * from user;
+----+--------+-------+
| id | name   | money |
+----+--------+-------+
|  1 | a      |  1000 |
|  2 | b      |  1000 |
|  3 | 小明   |  1000 |
|  4 | 淘宝店 |  1000 |
|  5 | c      |   100 |
|  6 | d      |  1000 |
|  7 | 赵铁柱 |  1000 |
+----+--------+-------+

这说明：当user表被另外一个事务操作的时候，其他事务里面的操作是不可以进行的，会进入排队状态（串行化），直到张全蛋那边事务结束后（commit）,王尼玛这边的读取操作才会执行。（在没有等待超时的情况下）

我们继续演示：

此时王尼玛这边处于：刚读取完数据的状态，事务还没有结束，我们让张全蛋在这个时候插入一条数据

 insert into user values(8,'李诞',1000);

发现会卡住，（因为王尼玛的事务正在进行还没有结束），所以我们只能让王尼玛

mysql> rollback;
Query OK, 0 rows affected (0.00 sec)

回滚操作后（王尼玛这边的事务结束），这时我们发现张全蛋那边卡住的数据也插入成功了

mysql> insert into user values(8,'李诞',1000);
Query OK, 1 row affected (32.71 sec)

由此我们进一步可以看出，在这种串行化的隔离状态下（隔离级别最高），它已经解决了幻读造成的问题（因为这边的事务未结束，另一边的事务只能处于阻塞等待状态，自然不会发生另一边事务提交了，而这边事务不知道，继续插入和另一边相同的数据而造成的幻读现象），当然之前的脏读，不可重复读现象更不会发生了。

串行化的问题是：性能特差！！！

性能由高到低：（1）read uncommitted > read committed; > repeatable read; > serializable;

隔离级别越高，性能越差。

MySQL默认隔离级别是： repeatable read

码字不易，欢迎点赞，转载请注明出处！