关于mysql:MYSQL事务详解

学习一个货色，还是先从其概念开始，第一个问题：首先先看看什么是事务？

数据库事务是拜访并可能操作各种数据项的一个数据库操作序列，这些操作要么全副执行，要么全副不执行。

从这个概念看，事务就是一组SQL，而且这组SQL要么全副执行，要么全副不执行。

那么第二个常见的问题，事务有哪些个性（点）呢？这是一个很常见的考题。

事务的四大个性：A（Atomicity）C（Consistency）I（Isolation）D（Durability），如何了解这四个个性呢？

1.原子性（Atomicity）：事务开始后的所有操作，要么全副做完，要么全副不做，不可能做一半的状况，如果事务执行过程中出错，会回滚到事务开始前的状态，也就是事务是一个不可分割的整体。

2.一致性（Consistency）：事务开始前和完结后，数据库的完整性束缚没有被毁坏。比方A向B转账，A扣了钱，B就肯定会收到，不存在A这边减了，B那边没有加的状况。

3.隔离性（Isolation）：同时产生的事务（并发事务）不应该导致数据库处于不统一的状态中。零碎中每个事务都应该像惟一事务一样执行。任何事务都不应该影响其余事务的存在。如果A向B转账的同时，A齐全转移所有的钱，两个事务应该独立进行，在进行转账前要确认好余额。对于隔离性，前面会具体介绍。

4.持久性（Durability）事务实现后，事务对数据库的所有更新将被保留到数据库（磁盘），不能回滚，也能够了解为：无论db或零碎是否故障，数据都会永恒保留在磁盘上，不会丢。

那Mysql是否反对事务，Mysql有多种存储引擎，包含MyISAM, Innodb, Memory, Merge等。这其中，Innodb和BDB是反对事务的，MyISAM不反对事务。

Mysql如何执行事务呢？
1.启动事务

mysql> start transaction;或者mysql> begin;

2.执行你心愿在事务中运行的sql语句
3.执行commit语句，实现事务并提交数据

示例，假如有一张表student：

MySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  30 ||  2 | zhangsan |  28 ||  3 | lisi     |  28 |+----+----------+-----+

咱们来执行一个事务，将zhangsan的年龄改成22，具体语句如下：

#会话(事务)1MySQL [test]> begin;Query OK, 0 rows affected (0.01 sec)MySQL [test]> MySQL [test]> MySQL [test]> MySQL [test]> MySQL [test]> update student set age = 22 where id = 2;Query OK, 1 row affected (0.01 sec)Rows matched: 1  Changed: 1  Warnings: 0MySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  30 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 |+----+----------+-----+3 rows in set (0.01 sec)

此时咱们在会话1中没有执行commit，而后咱们在另一个会话窗口2查问下id=2的学生记录，年龄依然是28（只管在以后事务会话（会话1）中能查到最新数据22），因为前一个会话并没有commit（Mysql默认的事务隔离级别是可反复读），所以咱们读的依然是事务执行完之前的数据。

#会话(事务)2MySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  30 ||  2 | zhangsan |  28 ||  3 | lisi     |  28 |+----+----------+-----+3 rows in set (0.01 sec)

当我将会话窗口1执行commit后，此时会话2的查问后果如下：

#会话(事务)1MySQL [test]> commit;Query OK, 0 rows affected (0.00 sec)

#会话(事务)2MySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  30 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 |+----+----------+-----+3 rows in set (0.01 sec)

以上就是一个事务的执行过程。如果咱们想停止这个事务，不提交的话，能够应用rollback：

MySQL [test]> begin;Query OK, 0 rows affected (0.01 sec)MySQL [test]> update student set age = 32 where id = 1;Query OK, 1 row affected (0.01 sec)Rows matched: 1  Changed: 1  Warnings: 0MySQL [test]> select * from student where id = 1;+----+-------+-----+| id | name  | age |+----+-------+-----+|  1 | clark |  32 |+----+-------+-----+1 row in set (0.01 sec)MySQL [test]> rollback;Query OK, 0 rows affected (0.00 sec)MySQL [test]> select * from student where id = 1;+----+-------+-----+| id | name  | age |+----+-------+-----+|  1 | clark |  30 |+----+-------+-----+1 row in set (0.00 sec)

PS：聊聊autocommit
默认状况下，autocommit 的状态是ON，这意味着所有独自的语句一旦被执行就会被提交，除非该语句在begin….commit语句块中。想要查看autocommit值，能够应用：

MySQL [test]> show variables like 'autocommit';+---------------+-------+| Variable_name | Value |+---------------+-------+| autocommit    | ON    |+---------------+-------+1 row in set (0.01 sec)

如果autocommit的状态为off，则须要明确收回commit语句来提交事务。 要禁用autocommit，能够用上面命令：

MySQL [test]> set autocommit = 0;

PS: DDL语句，如create, alter, drop语句，都是无奈rollback的。

聊完事务的概念及事务的用法之后，对于事务，还有一个很常见的问题：事务的隔离级别，这也是个惯例考题。

事务的隔离级别，形容的是两个或多个事务同时产生时，一个事务与其余事务在资源或数据批改方面的隔离水平。事务的隔离级别有4个，别离是读未提交（read uncommitted），读已提交（read committed），可反复读（repeatable read），序列化（serializable）。

后面咱们提过 MYSQL默认的事务隔离级别是：可反复读（repeatable read），如何批改隔离级别呢？能够应用set @@transaction_isolation=’xxx’；来批改事务的隔离级别。

那接下来我来别离具体说说四个事务隔离级别：

1.读未提交（read uncommitted）：顾名思义，事务能够读取另一个未提交的事务写入的数据，读未提交也被称为脏读（因为它会导致脏读）。

咱们举个例子，

如果老板给你发工资，转的金额本来应该是2w，然而不小心手抖输错了数字，输成了2.5w，该钱已打到你的账户，然而事务还没有提交，然而此时，你去查看本人的账户，发现多了5k块，窃喜认为涨工资了，老板及时发现不对，马上回滚了事务，将数字改成了2w，再commit，你就蒙圈了，刚刚看了还是2.5w的，这就呈现了脏读

具体查问举例：

#会话1--会话1没有commitMySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  30 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 |+----+----------+-----+3 rows in set (0.00 sec)MySQL [test]> begin;Query OK, 0 rows affected (0.00 sec)MySQL [test]> update student set age = 29 where id = 1;Query OK, 1 row affected (0.00 sec)Rows matched: 1  Changed: 1  Warnings: 0

#会话2MySQL [test]> set session transaction isolation level read uncommitted;Query OK, 0 rows affected (0.00 sec)MySQL [test]> MySQL [test]> MySQL [test]> select @@tx_isolation;+------------------+| @@tx_isolation   |+------------------+| READ-UNCOMMITTED |+------------------+1 row in set, 1 warning (0.00 sec)MySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  29 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 |+----+----------+-----+3 rows in set (0.01 sec)

在会话2中能看到会话1未提交的事务，这种状况就是读未提交。读未提交会呈现脏读（一旦会话1 事务被rollback）

2.读已提交（read committed）：以后事务只能读取另一个事务提交的数据，这被称为不可反复读（non-repeatable read）,因为它会导致不可反复读。

具体举例：

#会话1MySQL [test]> set session transaction isolation level read committed;Query OK, 0 rows affected (0.01 sec)MySQL [test]> begin;Query OK, 0 rows affected (0.01 sec)MySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  33 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 ||  0 | wangwu   |  45 ||  0 | zhaoliu  |  22 |+----+----------+-----+5 rows in set (0.01 sec)MySQL [test]> update student set age = 25 where id = 1;Query OK, 1 row affected (0.00 sec)Rows matched: 1  Changed: 1  Warnings: 0MySQL [test]> commit;Query OK, 0 rows affected (0.01 sec)

#会话2MySQL [test]> set session transaction isolation level read committed;Query OK, 0 rows affected (0.00 sec)MySQL [test]> begin;Query OK, 0 rows affected (0.01 sec)MySQL [test]> select * from student;  //会话（事务）1--commit前 +----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  33 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 ||  0 | wangwu   |  45 ||  0 | zhaoliu  |  22 |+----+----------+-----+5 rows in set (0.01 sec)MySQL [test]> select * from student; //会话（事务）1--commit后+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  25 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 ||  0 | wangwu   |  45 ||  0 | zhaoliu  |  22 |+----+----------+-----+5 rows in set (0.01 sec)

能够留神到，在同一个事务会话2中，雷同的select语句获取不同的后果，一次age等于30,一次age等于29。所以呈现不可反复读

3.可反复读（repeatable read）

一个事务通过第一条语句只能看到雷同的数据，即便另一个事务已提交数据。在同一个事务中，读取通过第一次读取建设快照是统一的。一个例外，一个事务能够读取在同一个事务中更改的数据。

当事务开始并执行第一次读取数据时，将创立读取视图并放弃关上状态，直到事务完结。为了在事务完结之前提供雷同的后果集，InnoDB应用行版本控制和UNDO信息。假如事务1抉择了几行，另一个事务删除了这些行并提交了数据。如果事务1处于关上状态，它应该可能看到本人在开始时抉择的行。已被删除的行保留在 UNDO 日志空间中以履行事务1。一旦事务1操作实现，那些行便被标记为从UNDO日志中删除。这称为多版本并发管制（MVCC）。

具体举例：

#会话1MySQL [test]> set session transaction isolation level repeatable read;Query OK, 0 rows affected (0.00 sec)MySQL [test]> MySQL [test]> MySQL [test]> MySQL [test]> begin;Query OK, 0 rows affected (0.00 sec)MySQL [test]> select * from student;+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  25 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 ||  0 | wangwu   |  45 ||  0 | zhaoliu  |  22 |+----+----------+-----+5 rows in set (0.01 sec)MySQL [test]> update student set age = 27 where id = 1;Query OK, 1 row affected (0.00 sec)Rows matched: 1  Changed: 1  Warnings: 0MySQL [test]> commit;Query OK, 0 rows affected (0.00 sec)

#会话2MySQL [test]> set session transaction isolation level repeatable read;Query OK, 0 rows affected (0.01 sec)MySQL [test]> begin;Query OK, 0 rows affected (0.01 sec)MySQL [test]> select * from student; //会话（事务）1 commit 前+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  25 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 ||  0 | wangwu   |  45 ||  0 | zhaoliu  |  22 |+----+----------+-----+5 rows in set (0.01 sec)MySQL [test]> select * from student; //会话（事务）1 commit 后+----+----------+-----+| id | name     | age |+----+----------+-----+|  1 | clark    |  25 ||  2 | zhangsan |  22 ||  3 | lisi     |  28 ||  0 | wangwu   |  45 ||  0 | zhaoliu  |  22 |+----+----------+-----+5 rows in set (0.01 sec)

可反复读保障了在一个事务中，无论怎么查，后果都是统一，不受其余事务是否commit影响。从上例能够看出，事务1提交前后，事务2的查问后果都不变。

这就是咱们后面说的：当事务开始并执行第一次读取数据时，将创立读取视图并放弃关上状态，直到事务完结。为了在事务完结之前提供雷同的后果集。

从下面后果看，可反复读会产生幻读。那下面看下来，脏读，不可反复读，幻读有点像。那区别在哪呢？

脏读是指一个事务读取到了其余事务没有提交的数据，
不可反复读是指一个事务内屡次依据同一个查问条件查问进去的同一行记录的值不一样
幻读是指一个事务内屡次依据同个条件查出来的记录行数不一样

大家弄懂了几个的区别吗？如果没懂，能够细细品上述加粗字体

因为可反复读会产生幻读，于是就有第四个事务隔离级别：序列/串行化（serializable）

通过把选定的所有行锁起来，序列化能够提供最高级别的隔离。此级别与REPEATABLE READ相似，但如果禁用autocommit，则InnoDB会将所有一般SELECT语句隐式转换为SELECT…LOCKIN SHARE MODE；如果启用autocommit，则SELECT就是它本人的事务，并且序列化会期待被锁的行，总是读取最新提交的数据。

串行化，顾名思义，是将所有读写操作齐全串行。
串行化是所有隔离级别中最高的
每次读都须要取得表级共享锁，读写互相都会阻塞
串行化对资源的开销大，对并发反对不好，只在，某些场景下应用。

具体例子就不细列了，能够本人google

那么下面讲了这么多，当初来总结一下，以下是各个隔离级别的对照表：