mysql的事务隔离机制

最新推荐文章于 2025-09-19 10:56:40 发布
转载 最新推荐文章于 2025-09-19 10:56:40 发布 · 2.6k 阅读 · 0

MySQL 四种事务隔离级的说明

很早之前写的文章，重新回顾和学习下：

按照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个隔离级别的特点(上面的例子);

深入解析MySQL事务隔离级别及其实现原理
fudaihb的博客
09-09 2178
在数据库管理系统中，事务（Transaction）是保证数据一致性的重要机制。而事务隔离级别则是决定多个事务之间如何相互影响的关键。MySQL作为常用的关系型数据库，其事务隔离级别和实现机制在许多业务场景中起着至关重要的作用。本文将详细介绍MySQL的事务隔离级别、常见问题及其底层实现原理，帮助读者更好地理解和应用事务。
MySQL的四种事务隔离级别
08-26
MySQL的四种事务隔离级别 1、脏读 2、不可重复读 3、幻读
MySQL 四种事务隔离级的说明
weixin_30657541的博客
11-22 181
很早之前写的文章，重新回顾和学习下，也可以看这篇文章说明。 按照SQL:1992 事务隔离级别，InnoDB默认是可重复读的（REPEATABLE READ）。MySQL/InnoDB 提供SQL标准所描述的所有四个事务隔离级别。你可以在命令行用--transaction-isolation选项，或在选项文件里，为所有连接设置默认隔离级别。例如，你可以在my.inf文件的[mysqld]节里类似...
Mysql事务隔离级别、锁机制以及MVCC原理
最新发布
不积跬步无以至千里
09-19 1065
for update)的语句，事务才真正启动，才会向mysql申请真正的事务id，mysql内部是严格按照事务的启动顺序来分配事务id的。都实现了MVCC机制，对一行数据的读和写两个操作默认是不会通过加锁互斥来保证隔离性，避免了频繁加锁互斥，而在串行化隔离级别为了保证较高的隔离性是通过将所有操作加锁互斥来实现的。死锁指的是两个或多个事务在并发过程中，互相占用了对方所需的锁资源，并且都在等待对方释放，从而进入 无限等待 的状态。部分，详细描述了死锁涉及的事务、SQL 语句、等待的锁。事务在范围查询时使用了。
mysql中四种事务隔离描述_MySQL 四种事务隔离级的说明
weixin_39679678的博客
01-18 95
按照SQL:1992 事务隔离级别，InnoDB默认是可重复读的(REPEATABLE READ)。MySQL/InnoDB 提供SQL标准所描述的所有四个事务隔离级别。你可以在命令行用--transaction-isolation选项，或在选项文件里，为所有连接设置默认隔离级别。例如，你可以在my.inf文件的[mysqld]节里类似如下设置该选项：transaction-isolation =...
Mysql 四种事务隔离级别
haifeng_qu的博客
04-02 272
四种事务隔离级别read uncommited 读到未提交read commited 读到提交repeatable read 可重复读serializable 串行事务 read uncommited 读到未提交 事务中的修改，即时没有提交，对其他事务也是可见的 事务可以读到未提交的数据（脏读） 性能比其他级别好 实际很少使用 read commited 读到提交 大多数数据库系统的默认隔离级别（mysql 不是，mysql为 可重复读） 满足隔离性（一个事务开始时，只能看到已经提交的事务所做的修改）
【MySQL】MySQL事务隔离机制与实现原理详解（MySQL专栏启动）
qq_24428851的博客
08-21 1306
本文介绍MySQL事务的使用和其存在长事务的风险， MySQL 的事务及其特性，并发事务带来的问题、事务的隔离级别与演示，单版本控制锁以及多版本并发控制 MVCC。本文介绍MySQL事务的使用和其存在长事务的风险， MySQL 的事务及其特性，并发事务带来的问题、事务的隔离级别与演示，单版本控制锁以及多版本并发控制 MVCC。它的特点是间隙锁定，这仍然是默认级别。多版本控制，也称为MVCC，是指数据的多版本处理，以实现数据库中的高度并发数据访问，以及事务的可见性，以确保事务可以看到其应该看到的数据版本。
MySQL优化三：MySQL事务隔离机制、锁机制、MVCC机制及日志机制详解
zyh0110的博客
01-17 572
本节会对MySQL事务隔离机制、锁机制、MVCC机制及日志机制进行详解！！
MySQL中的事务隔离全详解
m0_53926113的博客
12-02 1343
如果 A 向 B 转账时，另一个事务查询账户 B 的余额，必须等到转账事务完成后才能看到更新后的数据，否则查询的结果可能不准确。：假设 A 和 B 的账户总余额为 1000 元，无论转账操作发生何种中断，事务的完成后，总余额必须仍然是 1000 元。事务读取数据时，会加共享锁（S 锁），其他事务无法修改；：如果银行系统发生断电，但 A 转账给 B 的操作已经提交，那么重启后，转账操作仍然有效，数据不会丢失。：一个事务在读取某个范围的数据时，发现范围内的数据被其他事务插入或删除了，导致前后查询结果不一致。
MySQL数据库事务隔离级别详解
12-16
MySQL数据库的事务隔离级别是数据库管理系统中用于控制事务处理中并发操作的重要机制。在多用户同时访问数据库的情况下，事务隔离级别能够确保数据的一致性和完整性，避免并发操作带来的各种问题，如脏读、不可重复...
MySQL 四种事务隔离级别详解及对比
12-16
MySQL 四种事务隔离级别详解及对比 按照SQL:1992 事务隔离级别，InnoDB默认是可重复读的（REPEATABLE READ）。MySQL/InnoDB 提供SQL标准所描述的所有四个事务隔离级别。你可以在命令行用–transaction-isolation选项，或在选项文件里，为所有连接设置默认隔离级别。 例如，你可以在my.inf文件的[mysqld]节里类似如下设置该选项： transaction-isolation = {READ-UNCOMMITTED | READ-COMMITTED | REPEATABLE-READ | SERIALIZABLE} 用户可以用SE
【mySQL】MySQL的四种事务隔离级别
我的笔记本
12-09 665
本文转自：https://www.cnblogs.com/huanongying/p/7021555.html （建议去原文查看，有评论） 本文实验的测试环境：Windows 10+cmd+MySQL5.6.36+InnoDB 一、事务的基本要素（ACID） 　　1、原子性（Atomicity）：事务开始后所有操作，要么全部做完，要么全部不做，不可能停滞在中间环节。事务执行过程中出错，...
mysql事务隔离机制原理
08-01
MySQL的事务隔离机制是通过不同的隔离级别来控制事务并发执行时的数据可见性和一致性。隔离级别越高，事务之间的隔离程度越好，但性能开销也越大。SQL标准定义了四种常见的事务隔离级别，MySQL也支持这四种级别，并且每种级别都有其特定的实现原理。 ### 事务隔离级别 MySQL支持以下四种事务隔离级别： 1. **未提交读（Read Uncommitted）**：这是最低的隔离级别，允许一个事务读取另一个事务未提交的数据。这种级别可能导致脏读（Dirty Read），即读取到无效的或未提交的数据。 2. **提交读（Read Committed）**：该级别确保一个事务只能读取到其他事务已经提交的数据。它避免了脏读，但可能会出现不可重复读（Nonrepeatable Read）和幻读（Phantom Read）。 3. **可重复读（Repeatable Read）**：这是MySQL的默认隔离级别。它确保在同一个事务中多次读取同一数据时，结果是一致的，即使其他事务对数据进行了修改并提交。可重复读级别解决了不可重复读的问题，但可能仍然存在幻读。 4. **串行化（Serializable）**：这是最高的隔离级别，通过强制事务串行执行来避免所有并发问题。它完全隔离了事务之间的数据访问，避免了脏读、不可重复读和幻读，但性能开销最大。 ### 实现原理 MySQL的事务隔离机制主要依赖于其存储引擎（如InnoDB）来实现。InnoDB通过多版本并发控制（MVCC）和锁机制来实现不同级别的隔离性。 - **一致性读（Consistent Read）**：InnoDB使用多版本并发控制（MVCC）来提供一致性读。在`REPEATABLE READ`隔离级别下，事务中的所有一致性读都读取事务开始时的快照。而在`READ COMMITTED`隔离级别下，事务中的每个一致性读都会读取最新的快照版本。一致性读不会对表加锁，因此多个事务可以并发地修改数据。 - **锁机制**：InnoDB支持行级锁和表级锁。在`READ COMMITTED`和`REPEATABLE READ`级别，InnoDB使用行级锁来控制并发访问。在`SERIALIZABLE`级别，InnoDB会对所有读取操作加锁，从而强制事务串行化执行。 - **不可重复读与幻读**：在`READ COMMITTED`级别，由于每次一致性读都会刷新快照，因此可能会出现不可重复读。而在`REPEATABLE READ`级别，事务在整个生命周期内使用同一个快照，因此避免了不可重复读。至于幻读，在`REPEATABLE READ`级别，InnoDB通过间隙锁（Gap Lock）来防止其他事务插入新行，从而避免了幻读。 ### 隔离级别与并发问题的关系 | 隔离级别 | 脏读 | 不可重复读 | 幻读 | 丢失更新 | |---------------------|------|------------|------|----------| | 未提交读（Read Uncommitted） | 可能 | 可能 | 可能 | 可能 | | 提交读（Read Committed） | 不可能 | 可能 | 可能 | 可能 | | 可重复读（Repeatable Read） | 不可能 | 不可能 | 不可能 | 可能 | | 串行化（Serializable） | 不可能 | 不可能 | 不可能 | 不可能 | ### 设置隔离级别 在MySQL中，可以通过以下命令设置事务隔离级别： ```sql SET [SESSION | GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}; ``` 例如，将当前会话的隔离级别设置为`READ COMMITTED`： ```sql SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; ``` ### 总结 MySQL的事务隔离机制通过不同的隔离级别和实现原理来平衡数据一致性和并发性能。选择合适的隔离级别取决于具体的应用场景和对数据一致性的要求。较高的隔离级别可以提供更强的数据一致性，但可能会降低系统的并发性能[^2]。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值