首页 / MYSQL / MySQL 四种事务隔离级的说明

MySQL 四种事务隔离级的说明

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了MySQL 四种事务隔离级的说明，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含9392字，纯文字阅读大概需要14分钟。

内容图文

很早之前写的文章，重新回顾和学习下，也可以看这篇文章说明。

按照SQL:1992 事务隔离级别，InnoDB默认是可重复读的（REPEATABLE READ）。MySQL/InnoDB 提供SQL标准所描述的所有四个事务隔离级别。你可以在命令行用--transaction-isolation选项，或在选项文件里，为所有连接设置默认隔离级别。
例如，你可以在my.inf文件的[mysqld]节里类似如下设置该选项：

transaction-isolation = {READ-UNCOMMITTED | READ-COMMITTED | REPEATABLE-READ | SERIALIZABLE}

用户可以用SET TRANSACTION语句改变单个会话或者所有新进连接的隔离级别。它的语法如下：

SET [SESSION | GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}

注意：默认的行为（不带session和global）是为下一个（未开始）事务设置隔离级别。如果你使用GLOBAL关键字，语句在全局对从那点开始创建的所有新连接（除了不存在的连接）设置默认事务级别。你需要SUPER权限来做这个。使用SESSION 关键字为将来在当前连接上执行的事务设置默认事务级别。任何客户端都能自由改变会话隔离级别（甚至在事务的中间），或者为下一个事务设置隔离级别。
你可以用下列语句查询全局和会话事务隔离级别：

SELECT @@global.tx_isolation;
SELECT @@session.tx_isolation;
SELECT @@tx_isolation;

----以上手册中的理论知识;
===========================================================================================
隔离级别脏读（Dirty Read）不可重复读（NonRepeatable Read）幻读（Phantom Read）
===========================================================================================

未提交读（Read uncommitted）可能可能可能

已提交读（Read committed）不可能可能可能

可重复读（Repeatable read）不可能不可能可能

可串行化（Serializable ）不可能不可能不可能

===========================================================================================

·未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据

·提交读(Read Committed)：只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别 (不重复读)

·可重复读(Repeated Read)：可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻象读

·串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

用例子说明各个级别的情况：

① 脏读: 脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

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

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

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

mysql> insert into ttd values(1);
Query OK, 1 row affected (0.05 sec)

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |
+------+
1 row in set (0.00 sec)

session 2:
mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| REPEATABLE-READ        |
+------------------------+
1 row in set (0.00 sec)

mysql> select @@global.tx_isolation;
+-----------------------+
| @@global.tx_isolation |
+-----------------------+
| REPEATABLE-READ   |        --------该隔离级别下(除了 read uncommitted)
+-----------------------+
1 row in set (0.00 sec)

mysql> select * from ttd;
Empty set (0.00 sec)              --------不会出现脏读

mysql> set session transaction isolation level read uncommitted;
Query OK, 0 rows affected (0.00 sec)

mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| READ-UNCOMMITTED       |   --------该隔离级别下
+------------------------+
1 row in set (0.00 sec)

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |                                       --------REPEATABLE-READ级别出现脏读

+------+
1 row in set (0.00 sec)

结论:session 2 在READ-UNCOMMITTED 下读取到session 1 中未提交事务修改的数据.
② 不可重复读:是指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

session 1:
mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| READ-COMMITTED         |
+------------------------+
1 row in set (0.00 sec)

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

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |
+------+
1 row in set (0.00 sec)

session 2 :

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

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

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |
+------+
1 row in set (0.00 sec)

mysql> insert into ttd values(2);  /也可以更新数据
Query OK, 1 row affected (0.00 sec)

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |
|    2 |
+------+
2 rows in set (0.00 sec)

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

session 2 提交后,查看session 1 的结果;

session 1:

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |                             --------和第一次的结果不一样,READ-COMMITTED 级别出现了不重复读
|    2 |
+------+
2 rows in set (0.00 sec)

③ 可重复读:

session 1:
mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| REPEATABLE-READ        |
+------------------------+
1 row in set (0.00 sec)

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

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |
|    2 |
+------+
2 rows in set (0.00 sec)

session 2 :

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

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

mysql> insert into ttd values(3);
Query OK, 1 row affected (0.00 sec)

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

session 2 提交后,查看session 1 的结果;

session 1:

mysql> select * from ttd;
+------+
| id   |
+------+
|    1 |                                      --------和第一次的结果一样,REPEATABLE-READ级别出现了重复读
|    2 |
+------+
2 rows in set (0.00 sec)

(commit session 1 之后 再select * from ttd 可以看到session 2 插入的数据3)

④ 幻读:第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

mysql>CREATE TABLE `t_bitfly` (
`id` bigint(20) NOT NULL default ‘0‘,
`value` varchar(32) default NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB

mysql> select @@global.tx_isolation, @@tx_isolation;
+-----------------------+-----------------+
| @@global.tx_isolation | @@tx_isolation  |
+-----------------------+-----------------+
| REPEATABLE-READ       | REPEATABLE-READ |
+-----------------------+-----------------+

实验一：

t Session A                   Session B
|
| START TRANSACTION;          START TRANSACTION;
|
| SELECT * FROM t_bitfly;
| empty set
|                             INSERT INTO t_bitfly
|                             VALUES (1, ‘a‘);
|
| SELECT * FROM t_bitfly;
| empty set
|                             COMMIT;
|
| SELECT * FROM t_bitfly;
| empty set
|
| INSERT INTO t_bitfly VALUES (1, ‘a‘);
| ERROR 1062 (23000):
| Duplicate entry ‘1‘ for key 1
v (shit, 刚刚明明告诉我没有这条记录的)

如此就出现了幻读，以为表里没有数据，其实数据已经存在了，傻乎乎的提交后，才发现数据冲突了。

实验二：

t Session A                  Session B
|
| START TRANSACTION;         START TRANSACTION;
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | a     |
| +------+-------+
|                            INSERT INTO t_bitfly
|                            VALUES (2, ‘b‘);
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | a     |
| +------+-------+
|                            COMMIT;
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | a     |
| +------+-------+
|
| UPDATE t_bitfly SET value=‘z‘;
| Rows matched: 2  Changed: 2  Warnings: 0
| (怎么多出来一行)
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | z     |
| |    2 | z     |
| +------+-------+

本事务中第一次读取出一行，做了一次更新后，另一个事务里提交的数据就出现了。也可以看做是一种幻读。
当隔离级别是可重复读，且禁用innodb_locks_unsafe_for_binlog的情况下，在搜索和扫描index的时候使用的next-key locks可以避免幻读。
再看一个实验，要注意，表t_bitfly里的id为主键字段。

实验三：
t Session A                 Session B
|
| START TRANSACTION;        START TRANSACTION;
|
| SELECT * FROM t_bitfly
| WHERE id<=1
| FOR UPDATE;
| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | a     |
| +------+-------+
|                           INSERT INTO t_bitfly
|                           VALUES (2, ‘b‘);
|                           Query OK, 1 row affected
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | a     |
| +------+-------+
|                           INSERT INTO t_bitfly
|                           VALUES (0, ‘0‘);
|                           (waiting for lock ...then timeout)
|                           ERROR 1205 (HY000):
|                           Lock wait timeout exceeded;
|                           try restarting transaction
|
| SELECT * FROM t_bitfly;
| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | a     |
| +------+-------+
|                           COMMIT;
|
| SELECT * FROM t_bitfly;

| +------+-------+
| | id   | value |
| +------+-------+
| |    1 | a     |
| +------+-------+

可以看到，用id<=1加的锁，只锁住了id<=1的范围，可以成功添加id为2的记录，添加id为0的记录时就会等待锁的释放。

实验四：一致性读和提交读
t Session A                      Session B
|
| START TRANSACTION;             START TRANSACTION;
|
| SELECT * FROM t_bitfly;
| +----+-------+
| | id | value |
| +----+-------+
| |  1 | a     |
| +----+-------+
|                                INSERT INTO t_bitfly
|                                VALUES (2, ‘b‘);
|                                COMMIT;
|
| SELECT * FROM t_bitfly;
| +----+-------+
| | id | value |
| +----+-------+
| |  1 | a     |
| +----+-------+
|
| SELECT * FROM t_bitfly LOCK IN SHARE MODE;
| +----+-------+
| | id | value |
| +----+-------+
| |  1 | a     |
| |  2 | b     |
| +----+-------+
|
| SELECT * FROM t_bitfly FOR UPDATE;
| +----+-------+
| | id | value |
| +----+-------+
| |  1 | a     |
| |  2 | b     |
| +----+-------+
|
| SELECT * FROM t_bitfly;
| +----+-------+
| | id | value |
| +----+-------+
| |  1 | a     |
| +----+-------+

如果使用普通的读，会得到一致性的结果，如果使用了加锁的读，就会读到“最新的”“提交”读的结果。
本身，可重复读和提交读是矛盾的。在同一个事务里，如果保证了可重复读，就会看不到其他事务的提交，违背了提交读；如果保证了提交读，就会导致前后两次读到的结果不一致，违背了可重复读。

可以这么讲，InnoDB提供了这样的机制，在默认的可重复读的隔离级别里，可以使用加锁读去查询最新的数据（提交读）。
MySQL InnoDB的可重复读并不保证避免幻读，需要应用使用加锁读来保证。而这个加锁度使用到的机制就是next-key locks。
总结:

四个级别逐渐增强，每个级别解决一个问题。事务级别越高,性能越差,大多数环境read committed 可以用.记住4个隔离级别的特点(上面的例子);

原文：https://www.cnblogs.com/qiumingcheng/p/8213770.html

内容总结

以上是互联网集市为您收集整理的MySQL 四种事务隔离级的说明全部内容，希望文章能够帮你解决MySQL 四种事务隔离级的说明所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1269572.html

来源：【匿名】

【上一篇】mysql 学习笔记4 【下一篇】用IE远程创建Mysql数据库的简易程序

更多 ►

【MySQL 四种事务隔离级的说明】教程文章相关的互联网学习教程文章

MySQL 四种事务隔离级的说明【代码】

很早之前写的文章，重新回顾和学习下，也可以看这篇文章说明。按照SQL:1992 事务隔离级别，InnoDB默认是可重复读的（REPEATABLE READ）。MySQL/InnoDB 提供SQL标准所描述的所有四个事务隔离级别。你可以在命令行用--transaction-isolation选项，或在选项文件里，为所有连接设置默认隔离级别。例如，你可以在my.inf文件的[mysqld]节里类似如下设置该选项：transaction-isolation = {READ-UNCOMMITTED | READ-COMMITTED | REPEATABLE...

MySql 的事务隔离级别

了解事务隔离级别之前先要了解数据库在高并发环境下会遇到的几个问题：脏读：事务 A 读取了事务 B 更新的数据，然后 B 执行回滚操作，那么 A 读到的就是脏数据。不可重复读：事务 A 多次读取同一个数据，事务 B 在事务 A 多次读取的过程中，对数据做了更新并提交，导致事务 A 多次读取同一个数据时，结果不一致。幻读：比如事务 A 将所有成绩从具体分数改为了 ABCDE 等级，但是事务 B 在这个时候插入了一条具体的分数，最后事务 A ...

mysql 事务回滚

begindeclare t_error integer default 0;declare continue handler for sqlexception set t_error=1;#set autocommit =0;start transaction;update mol_userlevelright set UserSetValue=20 where id=9;if t_error = 1 then rollback;else commit;select 1;end if; end原文：http://www.cnblogs.com/makqiq/p/6484567.html

MySQL ------ 事务处理（transaction）（二十八）【代码】【图】

MySQL支持的几种数据库引擎，并非所有的引擎都支持明确的事务处理管理，MYISAM 和 INNODB 是最常用的引擎，而MYISAM 不支持事务处理，innodb支持事务处理，所以一定要正确使用引擎类型。事务处理（transaction processing）：可以用来维护数据库的完整性，保证成批的MySQL操作要么完全执行，要么完全不执行。在关系型数据库设计把数据存储在多个表中，使数据更容易操纵、维护和重用。如：订单存储在orders 表和orderitems 表中，...

MySQL事务处理及字符集和校对顺序【代码】

一、事务处理事务处理：是一种机制，管理必须成批执行的MySQL操作，以保证数据库不包含不完整的操作结果。用来维护数据库的完整性。利用事务处理，可以保证一组操作不会中途停止，或作为整体执行或完全不执行（除非明确指示）。如果没有发生错误，整组语句写入数据库，如发生错误，则进行回退，以恢复数据库到某个已知且安全的状态。事务处理的几个重要术语：·事务：一组SQL语句；·回退：撤销指定SQL语句的过程；·提交：将未存储的...

MySQL事务autocommit自动提交

MySQL事务autocommit自动提交MySQL默认操作模式就是autocommit自动提交模式。这就表示除非显式地开始一个事务，否则每个查询都被当做一个单独的事务自动执行。我们可以通过设置autocommit的值改变是否是自动提交autocommit模式。通过以下命令可以查看当前autocommit模式mysql> show variables like'autocommit';+---------------+-------+| Variable_name | Value |+---------------+-------+| autocommit | ON |+----------...

关系型数据库---MySQL---事务【代码】

1、概述　　1.1　　事务：在对业务相关的一系列数据进行操作时，需要保证数据操作的完整性（要么全部成功、要么全部失败）；　　1.2　　MySQL中支持事务的存储引擎是：Innodb；　　1.3　　事务用来管理insert、update、delete语句；　　1.4　　事务必须满足的4个条件（ACID）：　　　　　　1.1.1　　Atomicity（原子性）　　　　　　　　　　　一个事务的所有操作，要么全部成功、要么全部失败　　　　　　1.1.2　　Consistency(一...

解决mysql 允许执行 XA RECOVER语句(atomikos 解决分布式事务报错)

当前访问mysql的账号root缺少系统权限，执行以下sql语句即可GRANT XA_RECOVER_ADMIN ON *.* TO root@‘%‘ ; 查看mysql当前访问用户的权限 show grants for 用户名@‘主机地址（%代表任意ip）‘ 参考：https://blog.csdn.net/qq_43028054/article/details/93138503mysql权限介绍链接：https://blog.csdn.net/qq_20387013/article/details/89875332 原文：https://www.cnblogs.com/jsfh/p/13404223.html

MySQL事务【代码】

1. 事务的介绍事务就是用户定义的一系列执行SQL语句的操作, 这些操作要么完全地执行，要么完全地都不执行，它是一个不可分割的工作执行单元。事务的使用场景:在日常生活中，有时我们需要进行银行转账，这个银行转账操作背后就是需要执行多个SQL语句，假如这些SQL执行到一半突然停电了，那么就会导致这个功能只完成了一半，这种情况是不允许出现，要想解决这个问题就需要通过事务来完成。2. 事务的四大特性原子性(Atomicity)一致性...

MySQL 事务功能【代码】

MySQL 事务功能事务： 1.介绍★事务：一组原子性的SQL查询、或者是一个或多个SQL语句组成的独立工作单元；★ACID测试：☉A：AUTOMICITY，原子性；整个事务中的所有操作要么全部成功执行，要么全部失败后回滚；☉C：CONSISTENCY，一致性；数据库总是应该从一个一致性状态转为另一个一致性状态；☉I：ISOLATION，隔离性；一个事务所做出的操作在提交之前，是否能为其它事务可见；出于保证并发操作之目的，隔离有多种级别； ☉D：DURA...

MySQL学习06（事务）【代码】【图】

事务概述什么是事务事务就是将一组SQL语句放在同一批次内去执行如果一个SQL语句出错,则该批次内的所有SQL都将被取消执行MySQL事务处理只支持InnoDB和BDB数据表类型事务的ACID原则原子性(Atomic) 整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执行过程中发生错误，会被回滚（ROLLBACK）到事务开始前的状态，就像这个事务从来没有执行过一样。一致性(Consist) 一个事务可以封装状态改变（...

MySQL数据库事务隔离级别【代码】【图】

数据库隔离级别有四种，应用《高性能mysql》一书中的说明：然后说说修改事务隔离级别的方法： 1.全局修改，修改mysql.ini配置文件，在最后加上1 #可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE. 2[mysqld] 3 transaction-isolation = REPEATABLE-READ 这里全局默认是REPEATABLE-READ,其实MySQL本来默认也是这个级别 2.对当前session修改，在登录mysql客户端后，执行命令：要记住mysql有一个a...

mysql事务【代码】

定义Transaction事务：一个最小的不可再分的工作单元；通常一个事务对应一个完整的业务(例如银行账户转账业务，该业务就是一个最小的工作单元)一个完整的业务需要批量的DML(insert、update、delete)语句共同联合完成事务只和DML语句有关，或者说DML语句才有事务。这个和业务逻辑有关，业务逻辑不同，DML语句的个数不同事务四大特征(ACID)原子性(A)：事务是最小单位，不可再分一致性(C)：事务要求所有的DML语句操作的时候，必须保证...

PHP与MYSQL事务处理

PHP与MYSQL事务处理 /*MYSQL的事务处理主要有两种方法。1、用begin,rollback,commit来实现begin 开始一个事务rollback 事务回滚commit 事务确认2、直接用set来改变mysql的自动提交模式MYSQL默认是自动提交的，也就是你提交一个QUERY，它就直接执行！我们可以通过set autocommit=0 禁止自动提交set autocommit=1 开启自动提交来实现事务的处理。当你用 set autocommit=0 的时候，你以后所有的SQL都将做为事务处理，直到你用commit确...

mysql事务【代码】

事务:一组操作, 要么都成功, 要么都失败特性: 原子性: 一组操作, 要么都成功, 要么都失败一致性(Consistency)：指事务发生前和发生后，数据的总额依然匹配隔离性(Isolation)：简单点说，某个事务的操作对其他事务不可见的持久性(Durability)：当事务完成后，其影响应该保留下来，不能撤消，只能通过“另开起一个事物”来抵消之前的错误场景: 我去银行给朋友汇款, ...

首页 / MYSQL / MySQL 四种事务隔离级的说明

MySQL 四种事务隔离级的说明

内容导读

内容图文

内容总结

内容备注

内容手机端

【MySQL 四种事务隔离级的说明】教程文章相关的互联网学习教程文章

事务 - 相关标签

MYSQL - 技术教程分类

MYSQL - 最新教程

MYSQL - 最热教程