InnoDB中事务隔离级别的说明

YQAG YQAG 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 1.8k累计阅读 1.8k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄14年
关注
原创 最新推荐文章于 2026-03-31 09:16:29 发布 1.8k 阅读 AI 写同款· GEO 优化 ›
MySQL面试题-事务（答案版） 事务是由 MySQL 的引擎来实现的，我们常见的 InnoDB 引擎它是支持事务的。不过并不是所有的引擎都能支持事务，比如 MySQL 原生的 MyISAM 引擎就不支持事务，也正是这样，所以大多数 MySQL 的引擎都是用 InnoDB。 阅读详情

我们都知道事务的几种性质，数据库中的一致性和隔离性等是实现事务的基本思想，在系统有大量的并发访问的情况下，了解和熟练应用数据库的本身的事务隔离级别，对于写出健壮性，并发处理能力强的代码还是起关键的作用。这里通过分析mysql InnoDB中事务的隔离级别，来抛砖引玉，让读者更好的理解，事务的隔离级别对于数据库数据的处理做了什么。

隔离级别 脏读（Dirty Read） 不可重复读（NonRepeatable Read） 幻读（Phantom Read）
未提交读（Read uncommitted） 可能 可能 可能
已提交读（Read committed） 不可能 可能 可能
可重复读（Repeatable read） 不可能 不可能 可能
可串行化（Serializable ） 不可能 不可能 不可能

·未提交读(Read Uncommitted)：一个事务可以读取到另一个事务中未提交的数据。
·提交读(Read Committed)：一个事务从开始直到提交之前，所做的任何修改对于其他事务都是不可见的。这个级别也叫不可重复读，因为两次执行的同样的查询，可能会得到不一样的结果。
·可重复读(Repeated Read)：该级别保证了在同一个事务中多次对去同样结果是一致的。但是该级别还是无法解决幻读的问题：当某个事务在读取某个范围内的记录时，另外一个事务又在该范围内容插入新的记录，则之前的事务提交事务后，再次读取该范围的记录会产生幻行。
·串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻塞

下面就使用真实的例子来说明各个级别的情况

CREATE TABLE `city` (
`id`  int(1) NOT NULL AUTO_INCREMENT ,
`name`  varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL ,
`state`  varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=utf8 COLLATE=utf8_general_ci
COMMENT='市级信息'
AUTO_INCREMENT=2147483647
ROW_FORMAT=COMPACT
;

1、未提交读(Read uncommitted)

session 1

mysql> select @@session.tx_isolation; --查询当前事务的隔离级别为RR
+------------------------+
| @@session.tx_isolation |
+------------------------+
| REPEATABLE-READ        |
+------------------------+
1 row in set

mysql> start transaction;
Query OK, 0 rows affected

mysql> INSERT INTO `city` (`id`, `name`, `state`) VALUES (3, '沧州', '河北');
Query OK, 1 row affected
session 2

mysql> select @@session.tx_isolation; --session2 当前回话隔离级别是RR
+------------------------+
| @@session.tx_isolation |
+------------------------+
| REPEATABLE-READ        |
+------------------------+
1 row in set

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set

mysql> set session transaction isolation level read uncommitted; --设置session2隔离级别为RU
Query OK, 0 rows affected

mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| READ-UNCOMMITTED       |
+------------------------+
1 row in set
mysql> select * from city;  --RU级别下是可以查到没有提交事务的数据的，这里出现了脏读
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set

由上可以得到，在未提交读(Read uncommitted)这个级别下，session2事务是可以读到session1中未提交事务的数据，这也就是脏读。所以这级别下是不能避免脏读的，所以这种隔离级别用到的可能性不大。

2、已提交读（Read committed）

session 1

mysql> set session transaction isolation level read committed; -- 修改session 1隔离级别为RC    
Query OK, 0 rows affected

mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| READ-COMMITTED         |
+------------------------+
1 row in set

mysql> start transaction;
Query OK, 0 rows affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+                                                     
session 2
mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| REPEATABLE-READ        |
+------------------------+
1 row in set

mysql> start transaction;
Query OK, 0 rows affected
mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set

mysql> INSERT INTO `city` (`id`, `name`, `state`) VALUES (3, '沧州', '河北');
Query OK, 1 row affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set
session 1
--session 2虽然插入了数据，但是未提交数据。
--sesion 1在RC级别下是查不到未提交数据，所以RC级别避免了脏读
mysql> select * from city; 
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set
session 2
mysql> commit;
Query OK, 0 rows affected
session 1
-- session 2事务提交，session 1在未提交事务情况下，
-- 查询数据查出了不同的结果，所以RC级别不能避免重复读导致的数据不一致
mysql> select * from city; 
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set

由上面内容可以得出，在RC级别下虽然避免的脏读的情况，但是不可避免重复读导致的两次查询不一致的情况。

3、可重复读（Repeatable read）

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

mysql> start transaction;
Query OK, 0 rows affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set

mysql> INSERT INTO `city` (`id`, `name`, `state`) VALUES (3, '沧州', '河北');
Query OK, 1 row affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set

mysql> commit;
Query OK, 0 rows affected
session 2 
mysql> select @@session.tx_isolation;
+------------------------+
| @@session.tx_isolation |
+------------------------+
| REPEATABLE-READ        |
+------------------------+
1 row in set

mysql> start transaction;
Query OK, 0 rows affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set
-- 直到sesion 1提交事务后,session 2也未查询到提交的新数据，所以RR级别下可以重复读。
mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set

session 2
-- 当session 2也提交事务后，再次查询，发现多了一条数据，这就说明RR级别下不能避免幻读的情况。
mysql> commit;
Query OK, 0 rows affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set

我们知道mysql的默认的隔离级别是RR。那在这种隔离级别下是怎么避免幻读的呢？

session 1

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

mysql> start transaction;
Query OK, 0 rows affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set

mysql> INSERT INTO `city` (`id`, `name`, `state`) VALUES (3, '沧州', '河北');
Query OK, 1 row affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set

mysql> commit;
session 2

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

mysql> start transaction;
Query OK, 0 rows affected

mysql> select * from city;
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
+----+--------+-------+
2 rows in set

mysql> select * from city for update;  --加X锁查询
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set

mysql> select * from city  LOCK IN SHARE MODE; 加S锁查询
+----+--------+-------+
| id | name   | state |
+----+--------+-------+
|  1 | 石家庄 | 河北  |
|  2 | 邯郸   | 河北  |
|  3 | 沧州   | 河北  |
+----+--------+-------+
3 rows in set

由上可以得出，一个事务中如果使用快照读，会得到一致性的结果，如果使用了加锁的读，就会读到其他事务提交的提交的最新的数据。

本身，已提交读（Read committed） 和可重复读（Repeatable read） 两个级别是矛盾的。在同一个事务里，如果保证了可重复读，就会看不到其他事务的提交，违背了提交读；如果保证了已提交读，就会导致前后两次读到的结果不一致，违背了可重复读。所以针对这种情况可以使用加锁去查询最新的数据。
MySQL InnoDB的可重复读并不保证避免幻读，需要应用使用加锁读来保证。

总结:
四个级别逐渐增强，每个级别解决一个问题。事务级别越高,性能越差,记住4个隔离级别的特点(上面的例子);

对于加锁查询后的数据其他事务想操作这些事务又会出现怎样的情况，这些就涉及到了数据库中S锁X锁的问题t，这些情况下还会有行锁，表锁等待的问题，这些内容会在下一篇文章中去详细的说明。

收录于
DataBase

当前文章被收录于：

DataBase
12 篇文章 0 人学习
订阅专栏 查看详情
标签
#MYSQL #Innodb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
MySQL 与 InnoDB：事务隔离级别详解 在数据库的世界里，事务就是一系列的操作，这些操作要么全部完成，要么全部不完成。比如转账，如果你从 A 账户转 100 元到 B 账户，那么这笔交易必须包括两步：从 A 减去 100 元和给 B 加上 100 元。这两步必须一起完成，否则数据库的状态就会出错。事务隔离级别是指多个事务同时运行时，数据库系统保证事务之间相互独立的程度。（读未提交）（读已提交）（可重复读）（串行化）每种隔离级别都有其特点和适用场景，下面咱们逐一介绍。通过以上的介绍和实战演练，我们可以看出不同事务隔离级别的优缺点。 阅读详情

相关推荐

nCode：GlyphWorks案例教程一

nCode GlyphWorks案例一Comparing Frequency Content of Two Different Tests案例文件目标配置选择数据 Comparing Frequency Content of Two Different Tests 在本案例中，我们将比较来自两个不同测试的六个加速计通道的频率内容。将三轴加速度计放置在车辆的左前角和右前角，然后分别在两个不同的试验路面上行驶12分钟以上。 案例文件 此案例的文件（采用nCode DAC格式）位于nCode安装目录下的\demo

追月行的博客 1万+

数据库之InnoDB可重复读隔离级别下如何避免幻读

文章目录一、先介绍几个概念1、什么是当前读2、什么是快照读3、什么是mvcc二、RR级别下避免幻读的方法三、RC级别下测试快照读和当前读3.1、测试快照读3.2、测试当前读四、RR级别下测试快照读和当前读五、RC、RR级别下的InnoDB的非阻塞读（快照读）如何实现主要undo log是干什么的read view呢六、next-key（行锁+gap锁）6.1、测试sql走唯一索引，并精准命中6.2...

不学习如何码遍天下 1798

excel wind插件使用_Python和wind的交互—在债券中的应用

个人认为学会了怎么用python和wind交互以及怎么用python处理Excel数据，就基本能替换日常很多琐碎的债券工作，还不用担心Excel某个值改变了导致整个报表都毁了。事实上在python调用wind函数和在Excel中调用函数一样简单，只要会基本的操作就够了。下面详细的介绍如何用python和wind进行交互。首先安装好python+pycharm+wind。因为python...

weixin_39863918的博客 5331

深入学习InnoDB可重复读隔离级别下如何避免幻读

一、InnoDB可重复读隔离级别下如何避免幻读 在理解什么是幻读之前，先了解下脏读、幻读、不可重复读在实操场景中的现象。 脏读：指的就是一个事务读取到了另一个事务还未提交的数据，当该事物将数据回滚，则读取到的就是脏数据。 脏读造成的结果：事务拿着脏的数据（还未提交的数据，如果回滚了）去执行业务操作，会影响业务。 脏读解决方案：将数据库事务隔离级别改为RC，所以事务只能读取到其他事务已经提交的数据。...

你要悄悄的拔尖，然后惊艳所有人 4185

手把手教你复现KDD 2024时空预测顶会论文：以UniST和ImputeFormer为例的代码实战与避坑指南

本文详细指导如何复现KDD 2024顶会论文中的UniST和ImputeFormer模型，涵盖环境配置、数据处理、模型训练及评估等关键步骤。通过实战案例和避坑指南，帮助研究者掌握时空预测与插补技术，提升在智慧城市、交通管理等领域的应用能力。

weixin_29204205的博客 279

先楫HPM6E00EVK EtherCAT从站配置与CIA402 8轴运动控制实战解析

本文详细解析了先楫HPM6E00EVK开发板的EtherCAT从站配置与CIA402 8轴运动控制实战。从环境准备、XML文件配置、代码移植到TwinCAT工程设置，提供了完整的移植指南，帮助开发者实现高效的多轴同步运动控制。

o5p6q的博客 416

MySQL 可重复读隔离级别，完全解决幻读了吗？

在mysql隔离可重复读级别中，针对快照读，用到了MVCC的方式解决幻读，针对当前读，用到了next-key lock解决幻读，但还有一些场景仍有幻读问题，这篇文章便是探讨这个问题！

m0_61227789的博客 2106

OpenClaw实战系列·进阶特辑02：多智能体协同——打造企业级AI中台

**企业级AI中台面临多Agent协同的挑战，本文提出基于多智能体协同的解决方案。通过分析单Agent的局限性（上下文溢出、专业度稀释等）和多Agent的核心优势（任务专注度、故障隔离等），提出三种协作架构模式（指挥型、联邦型、点对点型），并强调人格化设计的重要性。文章详细介绍Agent间通讯机制（同步/异步会话、文件系统协作）和"身脑分离"的解耦架构设计，提供可落地的企业级AI中台实施方案。

PeterPan的博客 494

进程间的通信方式（六种）

进程之间的通信 参考文章：https://blog.youkuaiyun.com/qq_34827674/article/details/107678226 前提知识：每个进程都有自己的用户空间，而内核空间是每个进程共享的。因此进程之间想要进行通信，就需要通过内核来实现。 管道： 管道是最简单，效率最差的一种通信方式。 管道本质上就是内核中的一个缓存，当进程创建一个管道后，Linux会返回两个文件描述符，一个是写入端的描述符，一个是输出端的描述符，可以通过这两个描述符往管道写入或者读取数据。 如果想要实现两个进程通过

OYMNCHR的博客 6万+

Python 爬虫实战：网站反爬机制绕过终极指南（技术原理 + 实战代码 + 避坑技巧）

在 Python 爬虫的世界里，反爬机制是每一个爬虫开发者都必须面对的挑战。网站为了保护自身数据不被恶意爬取，会设置各种反爬机制，这使得爬虫开发变得更加复杂和有趣。本文将详细介绍常见的网站反爬机制及其绕过方法，结合技术原理、实战代码和避坑技巧，帮助你成为一名优秀的爬虫开发者。

u014481728的博客 1006

基于STM32H5的循环GPDMA链表使用

STM32H503的GPDMA链表模式可实现灵活的数据传输。相比传统DMA直接编程方式，链表模式通过配置多个节点实现分散数据传输，支持循环链表功能。示例展示了如何使用GPDMA链表实现UART1循环发送数据：配置两个DMA节点分别指向不同发送缓冲区，构建循环链表并绑定到DMA通道。关键点包括：清空链表结构体、正确设置循环模式、检查节点配置。此方法提高了DMA使用的灵活性，适用于需要交替传输多段数据的场景。

kevin1499的博客 452

【Unix编程】进程间通信（IPC）

进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 一、管道 管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。 ...

dbbaq24022的专栏 3014

《QT+PCL 第一章》：点云读取显示

点云读取显示一、核心代码二、QT设置三、效果展示 一、核心代码 二、QT设置 三、效果展示

阁楼 1万+

Mysql Innodb 事务隔离级别说明

事务的四种隔离级别包括以下： 未提交读（Read uncommitted）允许脏读，也就是可以读取到其他事务未提交的数据。 已提交读（Read committed）避免脏读，只能读取已经提交的数据，重复读可能读取到不一样的数据源。 可重复读（Repeatable read）可重复读，同一事务内重复读可以读取到一样的数据，InnoDB默认事务隔离级别，但是还是会有幻读的可能性。 可串行化（Seri...

wangbaolongaa的专栏 247

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

VC中sqlite的使用

在VC中对sqlite的使用，实现数据库大批数据的快速插入，读取数据库中的数据在ListCtrl中显示

MySQL Innodb中的事务隔离级别和锁的关系1

我们都知道事务的几种性质，数据库为了维护这些性质，尤其是一致性和隔离性，一般使用加锁这种方式。同时数据库又是个高并发的应用，同一时间会有大量的并发访问，如果加锁过度，会极大的降低并发处理能力。所以对于加锁的处理，可以说就是数据库对于事务处理的精髓所在。这里通过分析MySQL中InnoDB引擎的加锁机制，来抛砖引玉，让读者更好的理解，在事务处理中数据库到底做了什么。

xingyi51的博客 844

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

Innodb中的事务隔离级别和锁的关系6

我们都知道事务的几种性质，数据库为了维护这些性质，尤其是一致性和隔离性，一般使用加锁这种方式。同时数据库又是个高并发的应用，同一时间会有大量的并发访问，如果加锁过度，会极大的降低并发处理能力。所以对于加锁的处理，可以说就是数据库对于事务处理的精髓所在。这里通过分析MySQL中InnoDB引擎的加锁机制，来抛砖引玉，让读者更好的理解，在事务处理中数据库到底做了什么。

qq_42878414的博客 959

Innodb中的事务隔离级别和锁的关系5

我们都知道事务的几种性质，数据库为了维护这些性质，尤其是一致性和隔离性，一般使用加锁这种方式。同时数据库又是个高并发的应用，同一时间会有大量的并发访问，如果加锁过度，会极大的降低并发处理能力。所以对于加锁的处理，可以说就是数据库对于事务处理的精髓所在。这里通过分析MySQL中InnoDB引擎的加锁机制，来抛砖引玉，让读者更好的理解，在事务处理中数据库到底做了什么。

2401_89357748的博客 859

mysql 开启事务_MySQL扫盲：一文详解MySQL InnoDB 事务

推荐阅读：吊打面试官！MySQL灵魂100问，你能答出多少？我凭借这份pdf拿下了蚂蚁金服、字节跳动、小米等大厂的offerMySQL5.5 及以后版本的默认存储引擎使用的是 InnoDB，接下来针对事务的讲解都是基于 InnoDB 存储引擎的。事务的定义事务：数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作; 事务是一组不可再分割的操作集合(工作逻辑单元)。典型事务使用场景：转账...

weixin_39996798的博客 227

mysql开启事务命令_MySQL扫盲：一文详解MySQL InnoDB 事务

推荐阅读：吊打面试官！MySQL灵魂100问，你能答出多少？我凭借这份pdf拿下了蚂蚁金服、字节跳动、小米等大厂的offerMySQL5.5 及以后版本的默认存储引擎使用的是 InnoDB，接下来针对事务的讲解都是基于 InnoDB 存储引擎的。事务的定义事务：数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作; 事务是一组不可再分割的操作集合(工作逻辑单元)。典型事务使用场景：转账...

weixin_39623620的博客 138

如何确认当前事务的隔离级别

导读我们知道可以在线修改全局或会话级的事务隔离级别，也可以修改时不指定GLOBAL/SESSION关键字，而只影响当前会话中的下一个事物，但怎么确认修改生效了呢？我们知道...

老叶茶馆 1566

InnoDB 事务处理机制

事务的起源可以追溯到 6000 年以前，当时苏美尔人（Sumerians）就发明了事务处理和记录方法。已知最早的记录是写在土块上的，上面记录的是皇家的税收、土地、谷物、牲畜、奴隶和黄金，明确地记下了每笔交易。这种早期的系统已经具备了事务处理的关键特征。记录使用的土块和记号方式就是数据库，每次土块的加入都会造成数据状态的变化，在今天可以称为事务。PS：事务是数据库关系系统中的一系列操作的一个逻辑单位。这种基于土块的事务处理系统的技术演变了数千年，经历了纸莎草纸、羊皮纸、最后到我们现在用的纸。

分享既学习 1911

MySql中的事务、MySql事务详解、MySql隔离级别

思考：我去银行给朋友汇款,我卡上有100元,朋友卡上50元,我给朋友转账50元,如果我的钱刚扣,而朋友的钱又没加时,网线断了, 怎么办（Transaction）是数据库管理系统（DBMS）中的一个核心概念，它确保了一系列数据库操作要么全部成功，要么全部失败，从而维护数据库的完整性和一致性。MySQL在5.5版本开始，就将InnoDB引擎作为默认存储引擎。由于Mysql中的事务是存储引擎实现，而且只有InnoDB支持事务。

2509_94198727的博客 996

Innodb中的事务隔离级别和锁的关系3

我们都知道事务的几种性质，数据库为了维护这些性质，尤其是一致性和隔离性，一般使用加锁这种方式。同时数据库又是个高并发的应用，同一时间会有大量的并发访问，如果加锁过度，会极大的降低并发处理能力。所以对于加锁的处理，可以说就是数据库对于事务处理的精髓所在。这里通过分析MySQL中InnoDB引擎的加锁机制，来抛砖引玉，让读者更好的理解，在事务处理中数据库到底做了什么。

qq_42878414的博客 994

Innodb中的事务隔离级别和锁的关系7

我们都知道事务的几种性质，数据库为了维护这些性质，尤其是一致性和隔离性，一般使用加锁这种方式。同时数据库又是个高并发的应用，同一时间会有大量的并发访问，如果加锁过度，会极大的降低并发处理能力。所以对于加锁的处理，可以说就是数据库对于事务处理的精髓所在。这里通过分析MySQL中InnoDB引擎的加锁机制，来抛砖引玉，让读者更好的理解，在事务处理中数据库到底做了什么。

2401_89357748的博客 615

mysql存储引擎与隔离级别_MySQL InnoDB存储引擎的事务隔离级别

我们知道，在关系数据库标准中有四个事务隔离级别：未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据提交读(Read Committed)：只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别可重复读(Repeated Read)：可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除...

weixin_39675926的博客 76
上一篇： MySQL EXPLAIN命令的总结
下一篇： MySQL 加锁处理分析
点赞 0
评论 0
书签 书签 4
YQAG
YQAG
博客等级 码龄14年 112粉丝 120原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值