MYSQL隔离级别及测试包括脏读，幻读

公众号【架构师也是人】 公众号【架构师也是人】 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 6.1k累计阅读 6.1k平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄18年
关注
原创 最新推荐文章于 2026-05-24 10:51:26 发布 6.1k 阅读 AI 写同款· GEO 优化 ›
面试官：说说事务的ACID，什么是脏读、幻读？ 一、事务 事务是数据库管理系统执行过程中的一个逻辑单位，由一个有限的数据库操作序列构成。–摘自百科 在MySQL里，事务是在引擎层面实现，比如MyIsam不支持，InnoDB支持 二、ACID 提到事务，肯定会想到 ACID 是吧，自行感受一下概念，然后我们来讲讲隔离性的问题。 原子性：事务的所有操作要么全部成功，要么全部回滚。 一致性：总是从一个一致性的状态转换到另一个一致性的状态... 阅读详情

概述

SQL标准定义了4类隔离级别，包括了一些具体规则，用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。
1. Read Uncommitted（读取未提交内容）
在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。
2. Read Committed（读取提交内容）
这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别 也支持所谓的不可重复读（Nonrepeatable Read），因为同一事务的其他实例在该实例处理其间可能会有新的commit，所以同一select可能返回不同结果。
3. Repeatable Read（可重读）
这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。不过理论上，这会导致另一个棘手的问题：幻读 （Phantom Read）。简单的说，幻读指当用户读取某一范围的数据行时，另一个事务又在该范围内插入了新行，当用户再读取该范围的数据行时，会发现有新的“幻影” 行。InnoDB和Falcon存储引擎通过多版本并发控制（MVCC，Multiversion Concurrency Control）机制解决了该问题。
4. Serializable（可串行化）
这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。
这四种隔离级别采取不同的锁类型来实现，若读取的是同一个数据的话，就容易发生问题。例如：
脏读(Drity Read)：某个事务已更新一份数据，另一个事务在此时读取了同一份数据，由于某些原因，前一个RollBack了操作，则后一个事务所读取的数据就会是不正确的。
不可重复读(Non-repeatable read):在一个事务的两次查询之中数据不一致，这可能是两次查询过程中间插入了一个事务更新的原有的数据。
幻读(Phantom Read):在一个事务的两次查询中数据笔数不一致，例如有一个事务查询了几列(Row)数据，而另一个事务却在此时插入了新的几列数据，先前的事务在接下来的查询中，就会发现有几列数据是它先前所没有的。
在MySQL中，实现了这四种隔离级别，分别有可能产生问题如下所示：

隔离级别脏读不可重复读幻读
Read Uncommitted√√√
Read Committed×√√
Repeatable Read××√
Serializable×××

测试

测试前准备

下面，将利用MySQL的客户端程序，分别测试几种隔离级别。测试数据库为test，表为t1；表结构：
通过mysql -uxxxx -p 打开客户端窗口MYSQL_A

mysql> desc t1;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | YES  |     | NULL    |       |
| name  | varchar(10) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.05 sec)

修改隔离级别方法：
用户可以用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;

##设置事务级别为未提交读
mysql> set global transaction isolation level read uncommitted;
Query OK, 0 rows affected (0.00 sec)
mysql> set session transaction isolation level read uncommitted;
Query OK, 0 rows affected (0.00 sec)
mysql> select @@global.tx_isolation;
+-----------------------+
| @@global.tx_isolation |
+-----------------------+
| READ-UNCOMMITTED      |
+-----------------------+
1 row in set (0.00 sec)
mysql> select @@tx_isolation;
+-----------------------+
| @@tx_isolation        |
+-----------------------+
| READ-UNCOMMITTED      |
+-----------------------+
1 row in set (0.00 sec)

修改事务自动提交

mysql> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.00 sec)

mysql> set autocommit = off;
Query OK, 0 rows affected (0.01 sec)

mysql> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | OFF   |
+---------------+-------+
1 row in set (0.00 sec)

修改完隔离级别及手动事务后。打开另一个mysql窗口，称为MYSQL_B

开始测试

测试Read Uncommitted（未提交读）

MYSQL_A执行：

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

mysql> insert into t1 values(1,'aa');
Query OK, 1 row affected (0.00 sec)

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

MYSQL_B执行：

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

MYSQL_A执行：

mysql> commit;
Query OK, 0 rows affected (0.00 sec)
mysql> insert into t1 values(2,'bb');
Query OK, 1 row affected (0.01 sec)

MYSQL_B执行：

mysql> select * from t1;
+------+------+
| id   | name |
+------+------+
|    1 | aa   |
|    2 | bb   |
+------+------+
2 rows in set (0.00 sec)

MYSQL_A执行：

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

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

MYSQL_B执行：

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

经过上面的实验可以得出结论，事务MYSQL_A插入了一条记录，但是没有提交，此时MYSQL_B可以查询出未提交记录。造成脏读现象。未提交读是最低的隔离级别。

注意 不论是【MYSQL_A】还是【MYSQL_B】每次开启事务，CRUD操作结束后要commit。否则影响其他事务操作。

测试Read Committed（已提交读）

MYSQL_A执行：

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

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

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

mysql> select @@tx_isolation;
+-----------------------+
| @@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 test.t1;
+------+-----------+
| id   | name      |
+------+-----------+
|    1 | ccFromMB5 |
|    2 | bb        |
|    3 | cc        |
|    4 | dd        |
+------+-----------+
4 rows in set (0.00 sec)

MYSQL_B执行：

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

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

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

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

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

mysql> insert into test.t1 values(5,'ee');
Query OK, 1 row affected (0.00 sec)

MYSQL_A执行：依然是4条记录。

mysql> select * from test.t1;
+------+-----------+
| id   | name      |
+------+-----------+
|    1 | ccFromMB5 |
|    2 | bb        |
|    3 | cc        |
|    4 | dd        |
+------+-----------+
4 rows in set (0.00 sec)

MYSQL_B执行：commit

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

MYSQL_A执行：

mysql> select * from test.t1;
+------+-----------+
| id   | name      |
+------+-----------+
|    1 | ccFromMB5 |
|    2 | bb        |
|    3 | cc        |
|    4 | dd        |
|    5 | ee        |
+------+-----------+
5 rows in set (0.00 sec)
#因为开始开启了手动事务，结束后别忘了commit
mysql> commit;
Query OK, 0 rows affected (0.00 sec)

经过上面的实验可以得出结论，已提交读隔离级别解决了脏读的问题，但是出现了不可重复读的问题，即事务A在B commit前后两次查询的数据不一致，因为在两次查询之间事务B插入了一条数据。已提交读只允许读取已提交的记录，但不要求可重复读。

测试Repeatable Read（可重读）

MYSQL_A 和 MYSQL_B执行：

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

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

MYSQL_A执行：

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

mysql> select * from test.t1;
+------+-----------+
| id   | name      |
+------+-----------+
|    1 | ccFromMB5 |
|    2 | bb        |
|    3 | cc        |
|    4 | dd        |
+------+-----------+
4 rows in set (0.00 sec)

MYSQL_B执行：

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

mysql> insert into test.t1 values(6,'fff');
Query OK, 1 row affected (0.00 sec)

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

mysql> update test.t1 set name = 'rere' where id =1;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

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

mysql> select * from test.t1;
+------+------+
| id   | name |
+------+------+
|    1 | rere |
|    2 | bb   |
|    3 | cc   |
|    4 | dd   |
|    5 | ee   |
|    6 | fff  |
+------+------+
6 rows in set (0.00 sec)

MYSQL_A执行：

#未执行commit
mysql> select * from test.t1;
+------+-----------+
| id   | name      |
+------+-----------+
|    1 | ccFromMB5 |
|    2 | bb        |
|    3 | cc        |
|    4 | dd        |
|    5 | ee        |
+------+-----------+
5 rows in set (0.00 sec)

mysql> commit;
Query OK, 0 rows affected (0.00 sec)
#执行commit后，查询出最新数据
mysql> select * from test.t1;
+------+------+
| id   | name |
+------+------+
|    1 | rere |
|    2 | bb   |
|    3 | cc   |
|    4 | dd   |
|    5 | ee   |
|    6 | fff  |
+------+------+
6 rows in set (0.00 sec)
测试传说中的Repeatable Read（可重读）下的幻读

为了让幻读重现，我们修改t1表的id字段为主键
MYSQL_A执行：

mysql> alter table test.t1 add primary key(id);
Query OK, 0 rows affected (0.06 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> desc test.t1;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| id    | int(11)     | NO   | PRI | 0       |       |
| name  | varchar(10) | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

OK，我们开始测试幻读
MYSQL_A执行：

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

mysql> select * from test.t1;
+----+------+
| id | name |
+----+------+
|  1 | rere |
|  2 | bb   |
|  3 | cc   |
|  4 | dd   |
|  5 | ee   |
|  6 | fff  |
+----+------+
6 rows in set (0.00 sec)

MYSQL_B执行：

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

mysql> insert into test.t1 values(7,'ggg');
Query OK, 1 row affected (0.01 sec)

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

mysql> select * from test.t1;
+----+------+
| id | name |
+----+------+
|  1 | rere |
|  2 | bb   |
|  3 | cc   |
|  4 | dd   |
|  5 | ee   |
|  6 | fff  |
|  7 | ggg  |
+----+------+
7 rows in set (0.01 sec)

MYSQL_A执行：

mysql> select * from test.t1;
+----+------+
| id | name |
+----+------+
|  1 | rere |
|  2 | bb   |
|  3 | cc   |
|  4 | dd   |
|  5 | ee   |
|  6 | fff  |
+----+------+
6 rows in set (0.00 sec)

mysql> insert into test.t1 values (7,'vvv');
ERROR 1062 (23000): Duplicate entry '7' for key 'PRIMARY'
在未提交当前事务时，查出来就6条，但是事务B已经提交了id为7的记录，这个时候，事务A会莫名的感到无助（提示：ERROR 1062 (23000): Duplicate entry '7' for key 'PRIMARY'），当提交A事务后，再查询就会发现id为7的记录已经存在。这就是Repeatable Read（可重读）下的幻读
mysql> commit;
Query OK, 0 rows affected (0.01 sec)

mysql> select * from test.t1;
+----+------+
| id | name |
+----+------+
|  1 | rere |
|  2 | bb   |
|  3 | cc   |
|  4 | dd   |
|  5 | ee   |
|  6 | fff  |
|  7 | ggg  |
+----+------+
7 rows in set (0.00 sec)

测试Serializable（串行化）

MYSQL_A 执行：

mysql> set global transaction isolation level serializable;
Query OK, 0 rows affected (0.00 sec)

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

mysql> select @@global.tx_isolation;
+-----------------------+
| @@global.tx_isolation |
+-----------------------+
| SERIALIZABLE          |
+-----------------------+
1 row in set (0.00 sec)

MYSQL_B依然是可重复读隔离级别。
MYSQL_A 执行：

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

mysql> select * from test.t1;
+----+------+
| id | name |
+----+------+
|  1 | rere |
|  2 | bb   |
|  3 | cc   |
|  4 | dd   |
|  5 | ee   |
|  6 | fff  |
|  7 | ggg  |
|  8 | hhh  |
+----+------+
8 rows in set (0.00 sec)

MYSQL_B 执行：

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

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

mysql> insert into test.t1 values(9,'iii');

这时，客户端会一直保持等待状态，不会打印出执行结果，直至A事务提交。
MYSQL_A 执行：

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

MYSQL_B 自动结束等待
一下这一句是A端执行commit后打印出的，可以看下执行时间。我等了23秒才手动在A端执行commit。

#这个是刚才insert等待的执行结果
Query OK, 1 row affected (23.41 sec)
#B端commit。
mysql> commit;
Query OK, 0 rows affected (0.01 sec)

MYSQL_A 执行：

mysql> select * from test.t1;
+----+------+
| id | name |
+----+------+
|  1 | rere |
|  2 | bb   |
|  3 | cc   |
|  4 | dd   |
|  5 | ee   |
|  6 | fff  |
|  7 | ggg  |
|  8 | hhh  |
|  9 | iii  |
+----+------+
9 rows in set (6.09 sec)

这里需要注意，如果B端insert后一直没有commit。那么A端同样会进入等待状态，直至B端提交事务。可以看下执行时间，我是先在A端执行查询，进入等待。然后在B端执行commit。随后A端结束等待查出B端插入的id为9的数据。可见，此隔离级别是最高的，也是最消耗资源、性能最差的级别。
serializable完全锁定字段，若一个事务来查询同一份数据就必须等待，直到前一个事务完成并解除锁定为止 。是完整的隔离级别，会锁定对应的数据表格，因而会有效率的问题。

Serializable可能造成B端插入的时候等待超时报错，如：ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction

收录于
Mysql

当前文章被收录于：

Mysql
36 篇文章 0 人学习
订阅专栏 查看详情
标签
#mysql隔离级别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
传输线末端短路、开路、加电感的反射系数 时，频率变化约300MHz, 出现这种偏差是因为我们的计算中将电磁波传播速率默认为。时，频率变化约300MHz, 出现这种偏差是因为我们的计算中将电磁波传播速率默认为。下图为用网络分析仪实测一长度为30cm的传输线末端加一0.6uH的线圈的反射系数。下图为用网络分析仪实测一末端短路的长度为30cm的传输线的反射系数。下图为用网络分析仪实测一末端开路的长度为30cm的传输线的反射系数。末端加电感相当于在传输线末端延长了一段后末端短路，使得相位下降速率。幅度为0dB, 相位由。幅度为0dB, 相位由。 阅读详情

相关推荐

从零理解域随机化：通过Isaac Lab的events.py掌握Sim-to-Real关键技术

本文深入解析域随机化技术如何通过Isaac Lab的events.py实现Sim-to-Real迁移，提升机器人策略在真实世界的鲁棒性。从刚体属性到环境条件的系统级随机化，详细介绍了工程实践中的关键参数配置与调试技巧，帮助开发者有效缩小仿真与现实的差距。

weixin_29062613的博客 260

Mysql模拟事物的隔离级别【脏读、不可重复读、幻读】

一、简介 未提交读(Read Uncommitted)：允许脏读，也就是可能读取到其他会话中未提交事务修改的数据。 提交读(Read Committed)：只能读取到已经提交的数据。Oracle等多数数据库默认都是该级别 (不重复读)。 可重复读(Repeated Read)：可重复读。在同一个事务内的查询都是事务开始时刻一致的，InnoDB默认级别。在SQL标准中，该隔离级别消除了不可重复读，但是还存在幻象读。 串行读(Serializable)：完全串行化的读，每次读都需要获得表级共享锁，读写相互都会阻

2152

LTspice仿真报错Timestep too small？5种实测有效的解决方法（附详细参数配置）

本文针对LTspice仿真中常见的“Timestep too small”报错，提供了5种经过实测有效的解决方案。从理解错误根源入手，详细介绍了调整求解器、仿真参数、优化精度容差、设置初始条件、为理想元件添加寄生参数以及使用高级指令等具体方法，并附有详细的参数配置步骤，帮助工程师快速定位并解决仿真收敛问题，提升电路设计效率。

weixin_29213655的博客 279

脏读幻读不可重复读的区别

1、脏读：脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。 例如： 张三的工资为5000,事务A中把他的工资改为8000,但事务A尚未提交。 与此同时， 事务B正在读取张三的工资，读取到张三的工资为8000。 随后， 事务A发生异常，而回滚了事务。张三的工资又回滚为5000。 最后， 事务B读取到的张三工资为8000的数据即为脏数据，事务B做了一次脏读。 2、不可重复读：是指在一个事务内，多次读同一数据。在这个事

xiangkou176的博客 3048

差分放大电路的计算

反馈，对于运算放大电路来说，运放工作在线性区，所以这里一定是负反馈，没有反馈（开环）或者是正反馈，那是比较器电路而不是放大电路，这时候运放工作在饱和区或称为非线性工作区，正因为饱和，输出才是电源电压的幅值。图2是一种带正反馈的运放电路，这里就不能叫运算放大电路了，因为运放的开环放大倍数理想是无限大，当然实际中不可能无限大，所以如下结构是迟滞电压比较器，运放工作在非线性区或饱和区。实际应用电路中，我们为了简化计算，也是用最简方法计算，经常使用的电路也是上述电路，令电阻相等关系，简化计算。

qq_40170041的博客 352

《炬丰科技-半导体工艺》用于半导体的RCA清洁技术

书籍：《炬丰科技-半导体工艺》 文章：用于半导体的RCA清洁技术 编号：JFKJ-21-1073 引言 RCA清洗技术是用于清洗硅晶圆等的技术，由于其高可靠性，30多年来一直被用于半导体和平板显示器(FPD)领域的清洗。其基础是以除去颗粒为目的的氨水-过氧化氢溶液组成的SC―1洗涤和以除去金属杂质为目的的盐酸-过氧化氢溶液组成的SC―2洗涤相结合的洗涤技术。SC-1洗涤的机理说明如下。首先，用过氧化氢氧化硅晶片的表面，用作为碱的氨蚀刻氧化硅，并通过剥离去除各种颗粒。此外，如图1所示，在pH 10.5附近的S

jfkj2021的博客 768

并发引起的事务问题 脏读 幻读 不可重复读测试

一. 环境准备 数据库版本：5.7.28 （ select version();） 连接数据库：mysql -h 120.55.xx.218 -P 3306 -u username -ppassword 操作表： CREATE TABLE `account` ( `id` int(11) NOT NULL AUTO_INCREMENT, `user_id` int(11) DEFAULT NULL, `amount` int(11) DEFAULT NULL, PRIMARY KEY (

无痕的博客 758

【量化交易】迅投QMT——基础操作新建策略导入策略！

策略指标 #基础操作 #新建策略 在【我的】主页，点击新建策略按钮 点击【pyhton策略】模型 会弹出一个策略编辑器框 【新建策略文件】 编辑完点击【编译】按钮 关闭策略编辑器 导入策略 券商 QMT：1. 点击进入【模型研究】界面2. 右键 -> 选择本地. rzrk导入 投研端：1. 点击【行情】界面,选择模型2. 右键 -> 选择本地. rzrk导入 #策略在副图作为指标运行 在主图上双击策略 VBA策略可以直接输出图像

weixin_eng02048的博客 4104

测试技能提升篇——脏读、不可重复读、幻读的区别

其实，脏写、脏读、不可重复读、幻读，都是因为业务系统会多线程并发执行，每个线程可能都会开启一个事务，每个事务都会执行增删改查操作。然后数据库会并发执行多个事务，多个事务可能会并发地对缓存页里的同一批数据进行增删改查操作，于是这个并发增删改查同一批数据的问题，可能就会导致我们说的脏写、脏读、不可重复读、幻读这些问题。

liwenxiang629的博客 428

QGIS中高效处理CAD数据的两种实用技巧

本文详细解析了在QGIS中高效处理CAD数据的两种核心方法。针对DWG/DXF文件在QGIS中直接打开失败的问题，介绍了使用QGIS内置数据导入管理器进行标准化转换的流程，并重点推荐了功能更强大的Another DXF Importer插件，以更好地保留文字、块属性等复杂信息。文章对比了两种方法的优劣与适用场景，并提供了坐标系设置、中文乱码等常见问题的避坑指南，帮助用户根据数据需求选择最佳导入策略。

weixin_28363123的博客 117

Shopee动态参数x-sap-Ri与x-sap-Sec逆向解析实战

现代电商前端反爬普遍采用动态参数校验机制，其核心是将设备指纹、DOM状态与时间上下文耦合生成不可复用的请求凭证。x-sap-Ri本质是渲染上下文唯一标识，依赖真实浏览器环境中的DOM树结构、Canvas像素指纹及毫秒级时间扰动；x-sap-Sec则是基于该标识与服务端同步密钥生成的HMAC-SHA256签名，具备强时效性与密钥轮换特性。这类机制显著提升了自动化采集门槛，广泛应用于Shopee商品详情页等高价值数据接口。本文聚焦于从Chrome DevTools调试出发，系统还原参数生成逻辑，覆盖DOM一致性

weixin_30603633的博客 896

MySQL　四种隔离级别

Mysql的四种隔离级别 SQL标准定义了4类隔离级别，包括了一些具体规则，用来限定事务内外的哪些改变是可见的，哪些是不可见的。低级别的隔离级一般支持更高的并发处理，并拥有更低的系统开销。 Read Uncommitted（读取未提交内容） 在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）。 Read Committed（读取提交内容） 这是大多数数据库系统的默认隔离级别（但不是M

weixin_44824389的博客 803

【漏洞复现】CVE-2024-44902 Thinkphp反序列化漏洞

Thinkphp v6.1.3至v8.0.4版本中存在反序列化漏洞，攻击者可利用此漏洞执行任意代码。

渗透之路，攻防之间皆学问 6705

再有人问你MySql 的隔离级别是什么，就把这篇文章发给他！

△Hollis, 一个对Coding有着独特追求的人△这是Hollis的第356篇原创分享作者 l zyz1992来源 l Hollis（ID：hollischuang）首先要明白什么...

HollisChuang's Blog 1384

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件，这是C++版本的破解文件

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Mysql事务(脏读,可重复读,幻读)测试

mysql事务测试 1、打开mysql的命令行，将自动提交事务给关闭 --查看是否是自动提交 1表示开启，0表示关闭 select @@autocommit; --设置关闭 set autocommit = 0; 2、数据准备 --创建数据库 create database tran; --切换数据库 两个窗口都执行 use tran; --准备数据 create table psn(id int primary key,name varchar(10)) engine=innodb; --插

Ru_yin_hai的博客 450

蓝牙模块HM-10手册

蓝牙模块HM-10手册，该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

mysql幻读和不可重复读的区别_面试官：MySQL的可重复读级别能解决幻读问题吗？...

作者：宁愿juejin.im/post/5c9040e95188252d92095a9e引言之前在深入了解数据库理论的时候，了解到事务的不同隔离级别可能存在的问题。为了更好的理解所以在MySQL数据库中测试复现这些问题。关于脏读和不可重复读在相应的隔离级别下都很容易的复现了。但是对于幻读，我发现在可重复读的隔离级别下没有出现，当时想到难道是MySQL对幻读做了什么处理？测试：创建一张测试用的表de...

weixin_36452340的博客 496

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的，已经排好版了，而且还是完整的，适合小白

laravel 事务_mysql的事务隔离和幻读和死锁问题

1.系统要通过严格的ACID测试,ACID表示原子性/一致性/隔离性/持久性原子性:一个事务必须被视为一个不可分割的最小工作单元一致性:数据库总是从一个一致性的状态转换到另外一个一致性的状态隔离性:通常来说一个事务所做的修改在最终提交以前对其他事务是不可见的持久性:一旦事务提交,则其所做的修改就会永久保存到数据库中2.sql标准中定义了四种隔离,较低级别的隔离可以执行更高的并发,开销也更低READ...

weixin_39538693的博客 497

MySQL的四种事务隔离级别

脏读 时间线 事务A 事务B 1 select age from user wehre id = 1;（查询结果：18） update user set age = 20 where id = 20 2 3 4 5 6 7

云丶言的博客 5340

4. MySQL事务隔离级别

事务A不会读取到事务B未提交的数据，只有事务B提交后事务A才会查看到修改后的数据。事务A启动后，会锁定整个表，后续其他事务B必须等待事务A结束后，才可正常执行。事务A启动后，在未提交前，查看数据时不会受到其他事务修改的影响。事务A会读取到事务B未提交的数据，产生脏读。

u010198709的博客 1696

mysql怎么进行事务测试_MySQL事务测试

mysql事务测试1、打开mysql的命令行，将自动提交事务给关闭--查看是否是自动提交 1表示开启，0表示关闭select @@autocommit;--设置关闭set autocommit = 0;2、数据准备--创建数据库create database tran;--切换数据库 两个窗口都执行use tran;--准备数据create table psn(id int primary key...

weixin_34226447的博客 1215

事务的四大特征和四个隔离级别

事务是应用操作里面严密的操作，所有操作必须一致完成，否则就会一起撤回原操作，也就是事务acid中的a（原子性），一个事务要么全部执行成功，要么全部执行失败。当事务总体提交时，事务的数据保持一致性，例如事务A和事务B各有1000元，他们进行转账操作，当转账完成后，他们的余额必须也是2000元。发现当事务A提交时，事务B自动修改成功 这是最高的隔离界别 解决了幻读，可重复读，脏读。事务与事务之间运行时互补打扰，即事务A和事务B操作各自的数据，并发状态下不能互相打扰。

qoldjdh123的博客 1902

MySQL InnoDB事务隔离级别脏读、可重复读、幻读（推荐理由，措辞准确）

1、MySQL InnoDB事务隔离级别脏读、可重复读、幻读MySQL InnoDB事务的隔离级别有四级，默认是“可重复读”（REPEATABLE READ）。·        1）.未提交读（READUNCOMMITTED）。另一个事务修改了数据，但尚未提交，而本事务中的SELECT会读到这些未被提交的数据（脏读）( 隔离级别最低，并发性能高 )。·        2）.提交读（READCOMM...

blogs_broadcast的博客 595

真正理解Mysql的四种隔离级别

什么是事务 事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做。 事务的结束有两种，当事务中的所以步骤全部成功执行时，事务提交。如果其中一个步骤失败，将发生回滚操作，撤消撤消之前到事务开始时的所以操作。 事务的 ACID 事务具有四个特征：原子性（ Atomicity ...

Bolg of EQuaker 246

mysql事务测试

mysql事务测试 1、打开mysql的命令行，将自动提交事务给关闭 --查看是否是自动提交 1表示开启，0表示关闭 select @@autocommit; --设置关闭 set autocommit = 0; 2、数据准备 --创建数据库 create database tran; --切换数据库 两个窗口都执行 use tran; --准备数据 create table psn(id i...

爱笑的k11的博客 314

MySQL 事务特性、四种隔离级别 （图示每一步的操作）和产生的问题

文章目录一、事务的基本要素（ACID）二、事务的并发问题三、MySQL事务隔离级别四、用例子说明各个隔离级别的情况4.1、读未提交：4.2、读已提交4.3、可重复读4.4、串行化五、补充： 本文实验的测试环境：Windows 10+cmd+MySQL5.6.36+InnoDB 一、事务的基...

猎人在吃肉 2310

MySQL面试题--常见的四种隔离级别

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_33750452的博客 968
上一篇： sysbench压力测试，mysql压力测试
下一篇： my.cnf和my.ini配置详解
点赞 3
评论 2
书签 书签 11
公众号【架构师也是人】
公众号【架构师也是人】
博客等级 码龄18年 565粉丝 146原创
+ 关注 专栏目录 订阅专栏
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值