为什么MYSQL在REPEATABLE READ下仍然返回未提交的记录？
在MySQL中，REPEATABLE READ是一种事务隔离级别，它保证在同一事务中多次读取同一数据时，结果始终保持一致。然而，即使在REPEATABLE READ级别下，MySQL仍然可能返回未提交的记录，这是由于以下原因：
- 脏读（Dirty Read）：在某个事务中，如果一个事务读取了另一个事务未提交的数据，那么就发生了脏读。在REPEATABLE READ级别下，MySQL默认禁止脏读，但是在某些情况下，MySQL允许脏读，例如使用了LOCK IN SHARE MODE或者FOR UPDATE的查询。
- 幻读（Phantom Read）：在某个事务中，如果一个事务读取了另一个事务已提交的数据后，再次读取同一范围的数据时，发现有新的数据插入，就发生了幻读。在REPEATABLE READ级别下，MySQL默认禁止幻读，但是在某些情况下，MySQL允许幻读，例如使用了LOCK IN SHARE MODE或者FOR UPDATE的查询。
- 非锁定读（Non-locking Read）：在REPEATABLE READ级别下，MySQL允许非锁定读，即读取未提交的记录。这是为了提高并发性能，但也导致了可能返回未提交的记录。
为了解决这些问题，可以采取以下措施：
- 使用锁定读（Locking Read）：在需要读取数据的同时，使用SELECT ... FOR UPDATE语句或者SELECT ... LOCK IN SHARE MODE语句，显式地对数据进行加锁，避免脏读和幻读的问题。
- 使用事务：将需要保持一致性的操作放在一个事务中，并设置适当的隔离级别。在MySQL中，可以使用START TRANSACTION语句开始一个事务，并使用COMMIT语句提交事务。
- 使用乐观锁或悲观锁：乐观锁通过在更新数据时检查数据版本号或时间戳来避免并发冲突，悲观锁则通过在读取数据时加锁来避免并发冲突。可以根据具体场景选择适合的锁机制。
腾讯云提供了多种与MySQL相关的产品和服务，例如：
- 云数据库 MySQL：提供稳定可靠的云端 MySQL 数据库服务，支持自动备份、容灾、监控等功能。详情请参考：云数据库 MySQL
- 云数据库 TencentDB for MySQL：提供高可用、高性能的云原生 MySQL 数据库服务，支持弹性扩容、备份恢复、性能优化等功能。详情请参考：云数据库 TencentDB for MySQL
- 云数据库 TDSQL-C：提供高可用、高性能的云原生 MySQL 兼容数据库服务，支持自动备份、容灾、监控等功能。详情请参考：云数据库 TDSQL-C
请注意，以上产品和服务仅作为示例，并非对其他云计算品牌商的推荐或评价。
相关·内容
对于上面的查询，为什么会话2仍然可以返回记录2？由于会话1尚未提交值为2.btw的记录，因此事务隔离级别是可重复读取，工具是MYSQL工作台。
CREATE TABLE `new_table` (
`C1` int(11) NOT NULL,
PRIMARY KEY (`C1`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
session 1
START TRANSACTION;
INSERT INTO new_table VALUES (2)
Session 2
SELECT * FROM new_table;
浏览 14提问于2017-07-31得票数 0
据我所知，Mysql DB的默认事务隔离级别是REPEATABLE_READ。(参见)。但是Mysql连接器8有以下代码：
public class DatabaseMetaData implements java.sql.DatabaseMetaData {
...
@Override
public int getDefaultTransactionIsolation() throws SQLException {
return java.sql.Connection.TRANSACTION_READ_COMMITTED;
}
}
他们只是忽略默认
浏览 14提问于2019-10-20得票数 4
回答已采纳
我有一个场景，其中我的集群处于读提交隔离模式，用例如下所示：
执行select语句大约需要1分钟才能运行查询并返回响应。
在此期间，可以在1分钟的时间范围内对数据进行更新(提交)。
那么，我的问题是，我是在答复中得到更新的记录还是旧的记录？我读过，它提到任何幻影读取都是允许的。
我在这里很困惑，所以只想弄清楚一点，请帮忙。
Using READ COMMITTED has additional effects(Reference MYSQL docs):
对于UPDATE或DELETE语句，InnoDB只对其更新或删除的行持有锁。在MySQL评估WHERE条件之后，将释放不匹配行的记录锁。
浏览 4提问于2021-01-01得票数 2
我正在用公开事务更新第一节中的一些记录-
begin transaction
update aa
set name = 'harry1'
where name = 'harry'
如您所见，未发出提交/回滚事务。现在我试着阅读另一次会议第2期会议的记录。
set transaction isolation level repeatable read
select * from aa
现在，隔离级别-可重复读取应该给出与会话1中update语句之前相同的旧值，应该是harry而不是harry1。如果我错了，请纠正我。但是，当我尝试在会话2中读取记录时，当事务在会话
浏览 2提问于2015-05-27得票数 1
回答已采纳
类的MySQLConnection方法似乎不像预期的那样工作。
>>> from mysql.connector import connect
>>> conn = connect(user = 'john', unix_socket = '/tmp/mysql.sock', database='db7')
>>> cur = conn.cursor()
>>> cur.execute("select @@session.tx_isolation")
>
浏览 5提问于2015-12-09得票数 0
回答已采纳
1回答
我有一个mysql进程，它执行一次读取和一次更新(在两个不同的表中)。为了确保读取速度，我将隔离级别更改为读取未提交。脏读是可以的，数据一致性并不重要。但它看起来是读未提交隔离级别，更新非常慢--事实上它会影响我的表中的其他写操作。
我的代码如下所示
SET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
SELECT ParentId INTO @ParentId FROM TableA where Id = var_ID;
UPDATE TableB SET Counter = Counter + 1 where Id =
浏览 0提问于2016-11-16得票数 4
2回答
我们有一个事务正在修改记录。事务必须调用web服务，如果服务失败，则回滚事务(因此它无法在手动之前提交)。因为记录被修改了，所以客户端应用程序对它有一个锁。但是，作为处理的一部分，web服务必须检索该记录才能从其中获取信息。砰，死锁。
我们使用websphere，基于困扰我的原因，默认为可重复读取隔离级别。我们将其删除到read_committed，认为这样可以在不寻找锁的情况下检索行。在我们的dev环境中，它似乎是有效的，但是在分阶段时，我们会陷入死锁。
我不是在问它为什么表现得不同，我们可能在某个地方犯了错误。我也没有询问上面web服务示例的具体内容，因为很明显，同样的事情也可能发生在其他
浏览 3提问于2014-06-08得票数 3
回答已采纳
1回答
我的桌子：
mysql> select * from users;
+-----+---------+--------+
| id | name | locked |
+-----+---------+--------+
| 10 | 1010 | 0 |
| 11 | xxx | 0 |
| 888 | 888 | 0 |
| 890 | qqq | 0 |
| 891 | qqq | 0 |
+-----+----
浏览 2提问于2014-07-17得票数 1
2回答
隔离级别为REPEATABLE_READ。
其逻辑如下：
Transaction begins
Read data from Table A
If (Table A has Any Data) End Transaction and exit
If Table A has No Data, Proceed further
Delete a record in Table B
Transaction ends
现在，我的问题是关于以下场景：
当前的执行到达第4点。
我在表A中插入数据(注意，当前的执行位于# 4)，该数据将返回#2中的一些结果。
现在，当前的执行将执行#5，它将删除不应该删除的记
浏览 0提问于2012-05-29得票数 5
我正在使用PostgreSQL9.2和C3p0 0.9.2.1，我创建了一个连接定制器来禁用autoCommit并设置transactionMode，但是当我在InitialContext上进行查找以检索dataSource时，连接上的autoCommit没有被禁用(底部的日志)。如何禁用自动提交？
连接定制器：
public class IsolationLevelConnectionCustomizer extends
AbstractConnectionCustomizer {
@Override
public void onAcquire(Connec
浏览 3提问于2013-07-04得票数 3
回答已采纳
1回答
我正在尝试使用sysbench基准测试(默认配置)生成一些图形，试图在MySQL中显示死锁和隔离级别之间的关系。
但我得到了一些简单的结果:我的印象是，可重复读取会比读取提交的死锁更多(事实就是这样)，但比未提交的读取要多得多。事实上，事实证明，未提交的read比任何一个都有更多的死锁。
这是正常的吗？如果是这样，为什么呢？
浏览 1提问于2012-02-10得票数 2
默认隔离级别：
mysql> SELECT @@TX_ISOLATION;
+-----------------+
| @@TX_ISOLATION |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set (0.00 sec)
Binlog：
mysqlbinlog mysql-bin.000078 --base64-output=DECODE-ROWS
....
/*!50718 SET TRANSACTION ISOLATION LEVEL READ COMMITTED*//*!*/;
在
浏览 0提问于2019-03-25得票数 0
在MySQL (特别是5.5)中，我们似乎有两种不同的方法来设置事务隔离级别。我只想知道我的想法是否正确
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ
就像
SET tx_isolation = 'REPEATABLE-READ'
其他可能的隔离级别也是如此。
编辑1
我还不够精确。@danihp对我的问题的回答是正确的。但实际上，我想问一下
SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ
对比
SET SESSION tx_isolation = 'REP
浏览 1提问于2017-11-30得票数 6
回答已采纳
这可能是一个非常普遍的问题。但是，我仍然无法找到合适的解决方案/答案，何时以及为什么要使用READ未提交隔离级别。大多数文章和spring说，最有效的方法是使用SERIALIZABLE。在这种情况下，为什么spring事务管理会出现读未提交和读提交隔离级别，如果它们没有效率的话。
我希望至少在这里我能得到答案。
提前感谢
浏览 0提问于2020-02-14得票数 1
回答已采纳
我们在MySQL中有一个使用InnoDB的表，我们使用的是未提交的事务隔离级别。为什么如图所示的设置@x会获得一个锁？
mysql> set @x = (select userID from users limit 1);
Query OK, 0 rows affected (0.02 sec)
mysql>
试图从另一个提示更新此表会导致超时错误：
mysql> update users set userID = 1;
ERROR 1205 (HY000): Lock wait timeout exceeded; try restarting transaction
浏览 5提问于2012-10-31得票数 8
1回答
我对REPEATABLE READ事务隔离级别的理解是，一旦设置了它，事务中读取的数据就不会改变。我使用了以下代码来验证这一点：
ctx = context.Background()
tx, _ := db.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelSerializable})
time.Sleep(5 * time.Second)
// do query on tx
当进程处于休眠状态时，我已经通过控制台插入了另一条记录。但是，新插入的记录已经出现在结果中。为什么是这样？我不想读取在事务开始后插入的记录。我也试过：
tx, _
浏览 2提问于2019-05-28得票数 0
回答已采纳
我正在尝试开发一个演示，以巩固我对REPEATABLE_READ隔离级别的理解。我尝试过使用hibernate和jdbc进行演示。JDBC按预期工作，但hibernate不起作用。
我的期望是，如果我在一个会话中读取一个数据库行，并且试图从另一个会话中写入相同的行，那么它应该被阻塞，直到第一个会话结束。
Hibernate:-当我在线程0和睡眠中“得到”一个对象(行)时，在线程1中我们尝试更新同一个对象(行)，线程1应该等到线程0提交。
class HibernateExample7_IsolationRR_Read_Write_Thread implements Runnable {
浏览 2提问于2013-02-23得票数 0
使用可重复读取的MySQL隔离级别。
给定表test具有非索引列quantity
id | quantity
--------------------
1 | 10
2 | 20
3 | 30
Tx1首先执行，注意尚未提交，这意味着所有获得的锁尚未释放。
Tx1：
START TRANSACTION;
DELETE FROM test WHERE quantity=10;
现在执行Tx2
Tx2：
START TRANSACTION;
INSERT INTO test(quantity) VALUES (40);
COMMIT
浏览 1提问于2018-11-23得票数 2
回答已采纳
最近，我们运行了一个测试，它同时创建了不同的Spring批处理作业实例(例如10个并行线程，作业名称相似但不同，例如前缀相同)。从MySQL异常中报告的死锁错误很容易触发
org.springframework.dao.DeadlockLoserDataAccessException: PreparedStatementCallback；SQL插入BATCH_JOB_INSTANCE(JOB_INSTANCE_ID，JOB_NAME，JOB_KEY，VERSION)值(?，?)；尝试锁定时发现死锁；尝试重新启动事务；嵌套异常是在尝试锁定时发现的com.mysql.jdbc.exception
浏览 11提问于2021-05-28得票数 0
回答已采纳
2回答
我正在学习InnoDB mvcc，我已经尝试了一个测试节目如下：
Mysql版本：
[root@mysql-test ~]# mysql --version
mysql Ver 15.1 Distrib 5.5.52-MariaDB, for Linux (x86_64) using readline 5.1
表模式：
MariaDB [liruifeng]> show create table test_a;
+--------+------------------------------------------------------------------------------
浏览 3提问于2017-08-30得票数 0
回答已采纳
2回答
所以我正在努力学习MySQL，我遇到了隔离级别(SERIALIZED, REPEATABLE READ, READ COMMITED, READ UNCOMMITED)。
我想我的问题很简单，但我没有在网上找到任何信息，所以我说：
如果我将默认的REPEATABLE READ更改为SERIALIZED，甚至从READ UNCOMMITED更改为另一个更高级别的隔离，那么出现死锁问题的可能性会更小吗？
提前感谢！
浏览 0提问于2020-06-11得票数 1
回答已采纳
1回答
比方说，数据库的隔离级别设置在READ_COMMITED。
然后通过spring事务管理将事务隔离级别设置为
1) READ_UNCOMMITED -那么该事务的有效隔离级别是什么？
2) REPEATABLE_READ -那么该事务的有效隔离级别是什么？
浏览 5提问于2017-08-11得票数 1
1回答
只读事务表锁定
、、、
我使用的是JPA2.0、Hibernate和MySQL。MySQL db的隔离是TRANSACTION_REPEATABLE_READ。我有一套查询，将用于显示数据在网站上。其中一些查询将需要获取大量行，并且可以通过其他进程在中间进行修改。对于那些只读查询，我是否需要使用任何类型的锁定(悲观或乐观)来确保结果集是一致的？
通过@Version注释在自动对象版本控制中使用乐观锁定是否对只读查询有任何意义？
我不知道为什么会有人必须在实体或查询上显式地指定LockModeType.OPTIMISTIC。如果对象是版本化的，那么无论如何都会在提交时检查它，对吗？
浏览 3提问于2011-11-06得票数 1
回答已采纳
数据以每秒100-200次插入的速度从多个服务器插入到一个表中。每个服务器以id顺序读取该表中的所有行，并在每隔几秒运行一次的计时器线程中处理数据。最后读入的id被存储在内存中，并在下一次查询期间再次使用。
发生的情况是，读取数据的函数不会读取某些行；当插入速率很高时，会跳过这些行。
这是一个场景。
读取数据的函数已经读入了ID100之前的数据。它现在尝试读取id> 100的行。返回的行数为101,102,104,105。跳过行103 (即使它存在)。
正在发生的事情的当前工作理论是，由于数据由多个服务器插入，行103在读取发生时尚未提交，因此不会作为结果集的一部分返回。提交很可能在此读
浏览 0提问于2011-05-20得票数 0
让我直截了当地谈谈问题。我有两个表，名为A和B。在表A中，我有一个触发器(在插入后)，它负责在表B中插入一行，其中包含NEW.ID。在表B中还有一个触发器(插入后)，它使用mysql调用php外部脚本，在UDF中传递NEW.table_A_ID。
问题:我无法读取表A中新插入的行。我可以读取n-1行，但不能读取第n行。默认情况下，mysql自动提交是1，我使用的引擎是INNODB。这个问题的解决办法是什么？
浏览 6提问于2014-04-11得票数 0
回答已采纳
2回答
并发控制和事务隔离级别之间的区别是什么？
我清楚地理解他们中的每一个，但是，我有一些问题将他们联系在一起。具体地说，我看到它们的功能有一些重叠，我不确定什么时候应该使用一个而不是另一个。或者两者都应该一起使用？
另外，使用可重复读取的悲观锁定是什么意思？repeatable read不是已经意味着所有要编辑的值都将被锁定吗？那么，为什么仍然需要悲观锁定呢？
浏览 1提问于2012-12-02得票数 9
回答已采纳
1回答
我有张有10^7张唱片的桌子。我所做的工作如下：
使用唯一键删除记录以标识它
将另一条记录的唯一键更新到我刚刚删除的记录
MySQL 5.7抱怨重复的密钥。从原理上看，命令序列如下所示：
create database foo;
use foo;
create table users(
`id` int(11) NOT NULL AUTO_INCREMENT,
`login` varchar(255) NOT NULL,
`email` varchar(255) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `login` (`logi
浏览 0提问于2020-02-04得票数 0
1回答
我正在寻找关于条目背后的信息。声明：
MySQL的默认隔离级别(可重复读取)可能会导致典型Django用法中的数据丢失。为了防止这种情况，并为了与其他数据库保持一致，默认的隔离级别现在被提交。如果需要，可以使用数据库设置使用不同的隔离级别。
正如我所理解的，可重复的阅读比阅读更严格，所以Django做什么来产生“数据丢失”是一个困扰我的问题。
是像prefetch_related这样的东西吗？或者在一般情况下，基于潜在的陈旧(线程中的早期UPDATE )制作一个SELECTED是或者可以被认为是数据池？或者更好的是--也许只有MySQL做了一些事情，或者有一个错误，使得它在可重复读取时
浏览 0提问于2019-08-07得票数 0
这些天，我提高了对事务隔离级别的了解。
特别是，我无法很好地理解Read Committed和Repeatable Read之间的区别。
示例：
表：“测试”(字段: ID_REC - Data)
事务A：
set transaction isolation level read committed;
begin transaction
update test
set DATA = 't1'
where ID_REC = 1
waitfor delay '00:00:20'
commit transaction
事务B：(相同，但有另一条记录)
set t
浏览 0提问于2017-01-02得票数 3
1回答
请提供一些建议，以下问题:我有一个独特的代码列表。代码必须只使用一次，因此与每个代码关联的状态(使用/不使用)。
如果多个线程试图获得下一个未使用的代码，我担心争用/争用的情况。
使用SQL数据库(在我的例子中是MySQL )实现它的最佳方法是什么？
第一个选项是使用锁定和读取提交的隔离级别：
start transaction in read-committed isolation level
select code from code_table where status = 'not-used' for update
update code_table set statu
浏览 0提问于2016-03-19得票数 1
回答已采纳
1回答
我在文档中读到了MySQL。然后，只有和讨论，如下所示：
READ提交的
即使在同一事务中，每个一致的读取都会设置和读取自己的新快照。
REPEATABLE读
这是InnoDB的默认隔离级别。在同一事务中进行一致读取，读取由第一次读取建立的快照。
快照
数据在特定时间的表示，即使其他事务提交了更改，数据表示也保持不变。由某些隔离级别使用，以允许一致读取。
因此，只有和使用MVCC(多版本并发控制)。
那么和呢？
浏览 3提问于2022-10-13得票数 0
我对Postgresql可重复读隔离级别有问题。当幻影阅读发生时，我确实做了一个关于可重复阅读隔离级别行为的实验。
该表还显示，PostgreSQL的可重复读取实现不允许幻像读取。
但出现了幻影阅读；
CREATE TABLE public.testmodel
(
id bigint NOT NULL
);
-第一次会议
BEGIN TRANSACTION ISOLATION LEVEL Repeatable Read;
INSERT INTO TestModel(ID)
VALUES (10);
Select sum(ID)
From TestModel
where ID betw
浏览 0提问于2019-04-04得票数 9
回答已采纳
我正在使用连接执行事务。每当第二个连接立即尝试更新刚刚插入的行时，就找不到行。即使事务是在发出更新之前提交的。
我有mysql查询日志，它描述了这个场景。
最后一条语句失败，0行受影响(UPDATE refresh_token...)：
2018-08-03T13:31:24.829038Z 1150 Query START TRANSACTION
2018-08-03T13:31:24.830026Z 1150 Prepare INSERT INTO account (<redacted>) VALUES (<redacted>)
2018-08-03T13:
浏览 0提问于2018-08-03得票数 1
回答已采纳
我有一个DB2隔离级别的情况，我无法解释。
我有一个隔离级别为REPEATABLE_READ的事务，在DB2中它对应于READ_STABILITY。
我对DB2的S锁、U锁和X锁有基本的了解。
当我并行执行下面的Spring事务时，我可能会导致死锁(来自DB2的错误是文件正在使用)：
@Transactional(isolation = Isolation.REPEATABLE_READ, propagation = Propagation.REQUIRES_NEW)
public long getNext(int x) {
final Stuff stuff = entityMana
浏览 24提问于2018-06-15得票数 0
我们有两个事务，一个是READ_COMMITTED，另一个是READ_UNCOMMITTED。我们在READ_COMMITTED事务中面临一个锁异常。当其他READ_UNCOMMITTED事务修改READ_COMMITTED试图检索的记录时，就会发生此异常。我的READ_UNCOMMITTED事务需要更多的时间来完成。根据隔离策略，READ_UNCOMMITTED不获取锁，READ_COMMITTED获取锁。
我的问题是
这里READ_COMMITTED遵循什么样的锁定策略。
它会从READ_UNCOMMITTED事务获得未提交记录的锁吗？或者在以前交易中提交的记录上。
浏览 2提问于2016-10-25得票数 1
我们使用Doctrine作为ORM、框架ZF1和ZF2以及数据库MySql。我知道innodb引擎的默认隔离级别是Repeatable Read。由于我使用Doctrine作为ORM，默认的isolation level是什么？在这个中，如下所示：
基础平台选择Doctrine\DBAL\Connection的默认事务隔离级别，但它始终至少是READ_COMMITTED。
让我更加困惑的是另一篇文章，那篇文章来自理论本身。我谨此如下：
这可能导致不可预测的结果，因为一个显式WITH (NOLOCK)表提示告诉Server在事务隔离级别上运行一个特定的查询，读取未提交的READ而不是默
浏览 10提问于2016-08-04得票数 3
回答已采纳
1回答
我有一个多线程应用程序，它周期性地获取MySQL表的全部内容(使用SELECT * FROM查询)，应用程序用python编写，使用线程模块进行多线程处理，并使用mysqldb (mysqldb)作为MySQL驱动程序(使用mysqlalchemy作为包装器生成类似的结果)。我使用InnoDB引擎作为MySQL数据库。
我编写了一个简单的测试来检查SELECT *查询的性能，并发现所有这些查询都是按顺序实现的。
我显式地将隔离级别设置为读未提交，尽管它似乎无助于性能。
执行DB调用的代码片段如下：
@performance.profile()
def test_select_all_raw_s
浏览 0提问于2014-02-07得票数 3
3回答
我的朋友描述了一个场景，并要求我找到解决方案。他使用Oracle数据库和JDBC连接，并将read提交作为事务隔离级别。在其中一个事务中，他更新记录，执行select语句并提交事务。当每件事情都发生在一个线程中时，一切都很好。但是当处理多个请求时，就会发生死锁。
线程-A更新记录。
线程B更新另一个记录。
线程-A发出select语句并等待Thread-B的事务完成提交操作。
线程-B发出select语句，等待Thread事务完成提交操作。
以上原因导致死锁。由于它们使用命令模式，基本框架只允许发出一次提交(在所有db操作结束时)，因此无法在select语句之前立即发出
浏览 3提问于2010-04-03得票数 3
2回答
当我从和读取时，如果事务级别是可重复的--读取任何其他事务都不能读取由该transaction.But访问的数据，我在测试时发现了这一点。* (MySQL服务器版本:5.0.21-community /innodb engine)*。
事务A:
mysql> SELECT @@tx_isolation;
+-----------------+
| @@tx_isolation |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set (0.00 sec)
mysql> SET auto
浏览 0提问于2013-04-25得票数 0
回答已采纳
2回答
简而言之，我的教授说，如果将下列事务都保留到默认的隔离级别(READ提交)，那么它们很容易被幻影读取。
BEGIN;
UPDATE product SET price = 100 WHERE type='Electronics';
COMMIT;
BEGIN;
UPDATE product SET price = 100 WHERE price < 100;
COMMIT;
我真的不知道幻影读是怎么发生的。
他还说，要解决这个问题，必须将第二个事务设置为REPEATABLE READ
所以..。为什么？幻影怎么会在这里发生，为什么REPEATABLE READ要修复它
浏览 0提问于2019-08-27得票数 0
回答已采纳
1回答
我正在使用Percona (MySQL)，目前正在开发一个具有多个使用该应用程序的用户的网络桌面应用程序。我的应用程序数据库不含事务，但在选择我必须使用的Transaction-Isolation时有问题，因为我的应用程序有财务记录，所以很敏感。那么，有人能帮我决定我必须使用哪种事务隔离吗？
浏览 1提问于2013-03-18得票数 1
回答已采纳
在带REPEATABLE_READ隔离的MySQL模式下，我的事务是这样的:通过pk选择一行，如果行不存在，则插入：
SELECT * FROM users where user_id = 10；INSERT INTO users(user_id)值(10)；
我的问题是，如果此行不存在，MySQL如何强制行锁以防止其他事务插入此行？
浏览 0提问于2011-01-16得票数 1
回答已采纳
我很想知道，当主键不存在时，两个并发的DELETE和使用主键的INSERT语句为什么会导致MySQL中的死锁。这个例子是为了用它最简单的形式来说明这个问题。
这是装置。
> SELECT @@GLOBAL.tx_isolation, @@tx_isolation;
+-------------------------+------------------+
| @@GLOBAL.tx_isolation | @@tx_isolation |
|-------------------------+------------------|
| REPEATABLE-READ
浏览 1提问于2018-06-06得票数 4
2回答
我们有这样的设想：
column)isolation Server 2008我们在db上进行了复制，我们有简单的sproc，它执行表之一的更改(添加新的级别是默认的(READ提交))
存储过程失败时出错：
您只能在读已提交或可重复读取隔离级别中指定READPAST锁
问题：
是什么引起问题的？如何解决这个问题？
更新：我认为这是非常常见的问题，所以我想知道为什么没有很好的解释为什么复制会导致这个问题
浏览 3提问于2012-05-08得票数 2
回答已采纳
1回答
我读了很多关于MySQL和InnoDB中的锁定和隔离级别的文章。
我理解技术上的差异和基本的方法，但我仍然无法理解这样一种情况:例如，READ UNCOMMITTED会给我比READ COMMITTED更好的性能。
下面是我的模拟：
CREATE TABLE `t` (
`i1` INT(11) NOT NULL,
`i2` INT(11) NULL DEFAULT NULL,
PRIMARY KEY (`i1`)
)
COLLATE='utf8_general_ci'
ENGINE=InnoDB;
insert into t values(10,10), (2
浏览 0提问于2016-03-19得票数 2
1回答
我需要澄清一下MySQL文档的摘录：
...conflicting锁可以通过不同的事务保持在间隙上。例如，事务A可以在间隙上持有共享间隙锁(间隙S-锁)，而事务B可以在同一间隙上持有独占间隙锁(间隙X-锁).
InnoDB中的gap锁“纯粹是禁止的”，这意味着它们只会阻止其他事务插入到Gap。它们不会阻止不同的事务在相同的间隙上使用gap锁。因此，间隙X锁具有与间隙S锁相同的效果.
我有一个表"aaa“，有两个列- number (主索引)和"mark”- VARCHAR (没有索引)。现在我执行：
Window1
SET TRANSACTION I
浏览 2提问于2018-02-22得票数 1
我们正在使用Mysql 5.6和主/从复制运行一个ROR应用程序。我们正面临僵局问题。
我们成功地在测试服务器上测试了将设置从REPEATABLE-READ更改为READ-COMMITTED (它们是独立的，而不是主/从)，从而消除了死锁问题：
transaction-isolation = READ-COMMITTED
当我们在主文件和从文件中添加相同的my.cnf文件时，不仅复制失败，而且应用程序也无法加载。
建议采用什么设置来适应此更改。还有别的选择吗？
浏览 0提问于2017-03-07得票数 1
1回答
mysql是如何实现读未提交的？
、、、、
我读过mysql，使用MVCC (乐观)解决READ_COMMITTED和REPEATABLE_READ隔离级别(和) 2PL (悲观)来解决SERIALIZABLE。但是没有提到它如何解决READ_UNCOMMITTED。
I使用READ_UNCOMMITTED隔离级别打开了两个mysql会话。在这两次会议中，我都试图更新相同的记录。在第一个会话中，它得到更新，但在第二个会话中，它等待第一个会话提交/回滚。谁锁了这个？因为这里显然没有MVCC或2PL的参与。
写-写冲突->也是如此，我在所有隔离级别上都看到了相同的行为，至少在READ_COMMITTED和REPEATABLE_READ
浏览 4提问于2021-07-23得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
