MySQL事务隔离级别----Repeatable read（重复读）

最新推荐文章于 2024-03-21 14:08:35 发布
最新推荐文章于 2024-03-21 14:08:35 发布
阅读量7.1k 收藏 16
点赞数 11
分类专栏： java sql 事务 文章标签： 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40831381/article/details/95914119
版权
java 同时被 3 个专栏收录
93 篇文章 1 订阅
订阅专栏
sql
22 篇文章 0 订阅
订阅专栏
事务
6 篇文章 0 订阅
订阅专栏

根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。数据库不同，其支持的事务隔离级别亦不相同：MySQL数据库支持上面四种事务隔离级别，默认为Repeatable read；Oracle 数据库支持Read committed和Serializable两种事务隔离级别，默认为Read committed。  

Repeatable read（重复读）：可以避免脏读和不可重复读，但可能出现幻读。

注意：事务隔离级别为可重复读时，如果检索条件有索引（包括主键索引）的时候，默认加锁方式是next-key 锁；如果检索条件没有索引，更新数据时会锁住整张表。一个间隙被事务加了锁，其他事务是不能在这个间隙插入记录的，这样可以防止幻读。

MySQL数据库，默认为Repeatable read（重复读）

数据库事务隔离级别设置为REPEATABLE-READ（重复读）：在并重启MySQL服务。  

 

 

脏读 

已知有两个事务A和B, A读取了已经被B更新但还没有被提交的数据，之后，B回滚事务，A读取的数据就是脏数据。

场景：公司发工资了，领导把5000元打到Tom的账号上，但是该事务并未提交，而Tom正好去查看账户，发现工资已经到账，账户多了5000元，非常高兴，可是不幸的是，领导发现发给Tom的工资金额不对，是2000元，于是迅速回滚了事务，修改金额后，将事务提交，Tom再次查看账户时发现账户只多了2000元，Tom空欢喜一场，从此郁郁寡欢，走上了不归路…...

分析：上述情况即为脏读，两个并发的事务：“事务B：领导给Tom发工资”、“事务A：Tom查询工资账户”

create table account(
	id int(36) primary key comment '主键',
      card_id varchar(16) unique comment '卡号',
      name varchar(8) not null comment '姓名',
      balance float(10,2) default 0 comment '余额'
)engine=innodb;

insert into account (id,card_id,name,balance) values (1,'6226090219290000','Tom',1000);

 数据库中数据显示： 

代码如下： 

public class Boss {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://127.0.0.1:3306/test";
			connection = DriverManager.getConnection(url, "root", "root");
			connection.setAutoCommit(false);
			statement = connection.createStatement();
			String sql = "update account set balance=balance+5000 where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			Thread.sleep(30000);//30秒后发现工资发错了
			connection.rollback();
			sql = "update account set balance=balance+2000 where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			connection.commit();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}
public class Employye {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://127.0.0.1:3306/test";
			connection = DriverManager.getConnection(url, "root", "root");
			statement = connection.createStatement();
			String sql = "select balance from account where card_id='6226090219290000'";
			resultSet = statement.executeQuery(sql);
			if(resultSet.next()) {
				System.out.println(resultSet.getDouble("balance"));
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}

演示流程：
先执行Boss类中main方法——>再执行Employye类中main方法——>Boss类中main方法执行完毕——>再执行Employye类中main方法——>观察Employye类中main方法输出


先执行Boss类中main方法——>再执行Employye类中main方法----运行结果：1000——>Boss类中main方法执行完毕——>再执行Employye类中main方法——>观察Employye类中main方法输出----> 30秒线程阻塞后，运行结果为3000 

 两个并发的事务：“事务B：领导给Tom发工资”、“事务A：Tom查询工资账户”，在Read committed（读已提交）级别下，事务A没有读取了事务B尚未提交的数据。 此时并没有出现脏读的情况，所以当事务的隔离级别为Repeatable read 的时候可以避免脏读。

 

不可重复读

已知有两个事务A和B，A 多次读取同一数据，B 在A多次读取的过程中对数据作了修改并提交，导致A多次读取同一数据时，结果不一致

场景：Tom拿着工资卡去消费，酒足饭饱后在收银台买单，服务员告诉他本次消费1000元，Tom将银行卡给服务员，服务员将银行卡插入POS机，POS机读到卡里余额为3000元，就在Tom磨磨蹭蹭输入密码时，他老婆以迅雷不及掩耳盗铃之势把Tom工资卡的3000元转到自己账户并提交了事务，当Tom输完密码并点击“确认”按钮后，POS机检查到Tom的工资卡已经没有钱，扣款失败，Tom十分纳闷，明明卡里有钱，于是怀疑POS有鬼，和收银小姐姐大打出手，300回合之后终因伤势过重而与世长辞，Tom老婆痛不欲生，郁郁寡欢，从此走上了不归路......

分析：上述情况即为不可重复读，两个并发的事务，“事务A：POS机扣款”、“事务B：Tom的老婆网上转账”，事务A事先读取了数据，事务B紧接了更新数据并提交了事务，而事务A再次读取该数据扣款

create table account(
	id int(36) primary key comment '主键',
  card_id varchar(16) unique comment '卡号',
  name varchar(8) not null comment '姓名',
  balance float(10,2) default 0 comment '余额'
)engine=innodb;

insert into account (id,card_id,name,balance) values (1,'6226090219290000','Tom',3000);
insert into account (id,card_id,name,balance) values (2,'6226090219299999','Lily',0);

数据库中结果显示：

代码如下：

public class Machine {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		try {
			double sum=1000;//消费金额
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://127.0.0.1:3306/test";
			connection = DriverManager.getConnection(url, "root", "root");
			connection.setAutoCommit(false);
			statement = connection.createStatement();
			String sql = "select balance from account where card_id='6226090219290000'";
			resultSet = statement.executeQuery(sql);
			if(resultSet.next()) {
				System.out.println("余额："+resultSet.getDouble("balance"));
			}
			
			System.out.println("请输入支付密码：");
			Thread.sleep(30000);//30秒后密码输入成功
			
			resultSet = statement.executeQuery(sql);
			if(resultSet.next()) {
				double balance = resultSet.getDouble("balance");
				System.out.println("余额："+balance);
				if(balance<sum) {
					System.out.println("余额不足，扣款失败！");
					return;
				}
			}
			
			sql = "update account set balance=balance-"+sum+" where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			connection.commit();
			System.out.println("扣款成功！");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}
public class Wife {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		try {
			double money=3000;//转账金额
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://127.0.0.1:3306/test";
			connection = DriverManager.getConnection(url, "root", "root");
			connection.setAutoCommit(false);
			statement = connection.createStatement();
			String sql = "update account set balance=balance-"+money+" where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			sql = "update account set balance=balance+"+money+" where card_id='6226090219299999'";
			statement.executeUpdate(sql);
			connection.commit();
			System.out.println("转账成功");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}

演示流程：
先执行Machine类中main方法——>再执行Wife类中main方法——>观察Machine类中main方法输出： 

两个并发的事务，“事务A：POS机扣款”、“事务B：Tom的老婆网上转账”，事务A事先读取了数据，事务B紧接了更新数据并提交了事务，而事务A再次读取该数据扣款时，数据没有发生了改变。 上面的结果显示并没有出现不可重复读,所有当事务的隔离级别设置为REPEATABLE-READ的时候可以避免不可重复读，妻子转账成功了，Tom也成功的支付了费用，但是卡中只有3000元，查看数据库中的数据：

Tom账户中的金额变成了负数这是因为：在数据库事务隔离级别为REPEATABLE-READ（重复读）的情况下，POS机读取工资卡信息（此时Tom工资卡余额3000元），Tom老婆进行了转账并提交了事务（此时Tom工资卡余额0元），Tom输入密码并点击“确认”按钮，POS机再次读取工资卡信息发现余额确实没有变化，但要最后一次读取的数据并不是来自于数据库物理磁盘，而是来自于缓存上的数据——MySQL数据库中“可重复读的隔离级别下使用了MVCC（https://blog.csdn.net/whoamiyang/article/details/51901888）select操作不会更新版本号，是快照读（历史版本）；insert、update和delete会更新版本号，是当前读（当前版本）”

 

幻读 

已知有两个事务A和B，A从一个表中读取了数据，然后B在该表中插入了一些新数据，导致A再次读取同一个表, 就会多出几行，简单地说，一个事务中先后读取一个范围的记录，但每次读取的纪录数不同，称之为幻象读

场景：Tom的老婆工作在银行部门，她时常通过银行内部系统查看Tom的工资卡消费记录。2019年5月的某一天，她查询到Tom当月工资卡的总消费额（select sum(amount) from record where card_id='6226090219290000' and date_format(create_time,'%Y-%m')='2019-05'）为80元，Tom的老婆非常吃惊，心想“老公真是太节俭了，嫁给他真好！”，而Tom此时正好在外面胡吃海塞后在收银台买单，消费1000元，即新增了一条1000元的消费记录并提交了事务，沉浸在幸福中的老婆查询了Tom当月工资卡消费明细（select amount from record where card_id='6226090219290000' and date_format(create_time,'%Y-%m')='2019-05'）一探究竟，可查出的结果竟然发现有一笔1000元的消费，Tom的老婆瞬间怒气冲天，外卖订购了一个大号的榴莲，傍晚降临，Tom生活在了水深火热之中，只感到膝盖针扎的痛......

分析：上述情况即为幻读，两个并发的事务，“事务A：获取事务B消费记录”、“事务B：添加了新的消费记录”，

create table account(
	id int(36) primary key comment '主键',
  	card_id varchar(16) unique comment '卡号',
  	name varchar(8) not null comment '姓名',
  	balance float(10,2) default 0 comment '余额'
)engine=innodb;
insert into account (id,card_id,name,balance) values (1,'6226090219290000','Tom',3000);

create table record(
	id int(36) primary key comment '主键',
    card_id varchar(16) comment '卡号',
    amount float(10,2) comment '金额',
    create_time date comment '消费时间'
)engine=innodb;
insert into record (id,card_id,amount,create_time) values (1,'6226090219290000',37,'2019-05-01');
insert into record (id,card_id,amount,create_time) values (2,'6226090219290000',43,'2019-05-07');

account数据库表中的数据：

record数据库表中的数据：

代码如下： 

public class Bank {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		ResultSet resultSet = null;
		try {
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://127.0.0.1:3306/test";
			connection = DriverManager.getConnection(url, "root", "root");
			connection.setAutoCommit(false);
			statement = connection.createStatement();
			String sql = "select sum(amount) total from record where card_id='6226090219290000' and date_format(create_time,'%Y-%m')='2019-05'";
			resultSet = statement.executeQuery(sql);
			if(resultSet.next()) {
				System.out.println("总额："+resultSet.getDouble("total"));
			}

			Thread.sleep(30000);//30秒后查询2019年5月消费明细
			
			sql="select amount from record where card_id='6226090219290000' and date_format(create_time,'%Y-%m')='2019-05'";
			resultSet = statement.executeQuery(sql);
			System.out.println("消费明细：");
			while(resultSet.next()) {
				double amount = resultSet.getDouble("amount");
				System.out.println(amount);
			}
			connection.commit();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}
public class Husband {

	public static void main(String[] args) {
		Connection connection = null;
		Statement statement = null;
		try {
			double sum=1000;//消费金额
			Class.forName("com.mysql.jdbc.Driver");
			String url = "jdbc:mysql://127.0.0.1:3306/test";
			connection = DriverManager.getConnection(url, "root", "root");
			connection.setAutoCommit(false);
			statement = connection.createStatement();
			String sql = "update account set balance=balance-"+sum+" where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			sql = "insert into record (id,card_id,amount,create_time) values (3,'6226090219290000',"+sum+",'2019-05-19');";
			statement.executeUpdate(sql);
			connection.commit();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}

演示流程：
先执行Bank类中main方法（Tom当月工资卡的总消费额为80元）——>再执行Husband类中main方法（此时Tom花费了1000元）——>观察Bank类中main方法输出：

30秒线程阻塞后打印的消费明细:  

两个并发的事务，“事务A：获取事务B消费记录”、“事务B：添加了新的消费记录”，事务A获取事务B消费记录时数据，而此时并不是避免了幻读，由mvcc机制可知，最后一次数据---打印出的消费明细是来自在缓存上的数据而不是磁盘上的，此时的数据库中消费记录多出了一条：

余生为莹
关注
  • 11
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MySQL数据库事务隔离级别详解
12-16
数据库事务隔离级别 数据库事务的隔离级别有4个，由低到高依次为 Read uncommitted：允许脏读。 Read committed： 防止脏读，最常用的隔离级别,并且是大多数数据库的默认隔离级别。 Repeatable read：可以防止脏读和不可重复读。 Serializable：可以防止脏读，不可重复读取和幻读，（事务串行化）会降低数据库的效率。 这四个级别可以逐个解决脏读 、不可重复读 、幻读 这几类问题。 √: 可能出现 ×: 不会出现 事务级别 脏读 不可重复读 幻读 Read uncommitted √ √ √ Read committed
事务隔离级别——REPEATABLE-READ（重复读）
Zzze0101的博客
06-08 7307
首先，我们先设置MySQL事务隔离级别为REPEATABLE-READ 在my.ini配置文件最后加上如下配置 #可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE. [mysqld] transaction-isolation = REPEATABLE-READ 重启MySQL服务 1、脏读 提出问...
mysql四种事务隔离级别，2024金三银四
最新发布
2401_82977171的博客
03-21 869
做任何事情都要用心，要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。当然要想成为一个技术大牛也需要一定的思想格局，思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局，未来你的路会走的更远。更多的技术点思维导图我已经做了一个整理，涵盖了当下互联网最流行99%的技术点，在这里我将这份导图分享出来，以及为金九银十准备的一整套面试体系，上到集合，下到分布式微服务[外链图片转存中…(img-A03S5P55-1711001303970)]本文已被。
Mysql事务隔离级别原理实例解析
12-14
引言 大家在面试中一定碰到过 说说事务的隔离级别吧？ 老实说，事务隔离级别这个问题，无论是校招还是社招，面试官都爱问！然而目前网上很多文章，说句实在话啊，我看了后我都怀疑作者弄懂没!因为他们对可重复读(Repeatable Read)和串行化（serializable）的解析实在是看的我一头雾水！ 再加上很多书都说可重复读解决了幻读问题，比如《mysql技术内幕–innodb存储引擎》等，不一一列举了，因此网上关于事务隔离级别的文章大多是有问题的，所以再开一文说明！ 本文所讲大部分内容，皆有官网作为佐证，因此对本文内容你可以看完后，你完全可以当概念记在脑海里，除非官网的开发手册是错的，否则
MySQL数据库事务隔离级别
02-26
数据库隔离级别有四种，应用《高性能mysql》一书中的说明：然后说说修改事务隔离级别的方法：1.全局修改，修改mysql.ini配置文件，在最后加上#可选参数有：READ-UNCOMMITTED,READ-COMMITTED,REPEATABLE-READ,SERIALIZABLE.2[mysqld]3transaction-isolation=REPEATABLE-READ这里全局默认是REPEATABLE-READ,其实MySQL本来默认也是这个级别2.对当前session修改，在登录mysql客户端后，执行命令：要记住mysql有一个autocommit参数，默认是on，他的作用是每一条
浅析MYSQL REPEATABLE-READ隔离级别
01-19
REPEATABLE-READ 即可重复读，set autocommit= 0或者START TRANSACTION状态下select表的内容不会改变。这种隔离级别可能导致读到的东西是已经修改过的。 比如: 回话一中读取一个字段一行a=1 在回话二里这个字段该行修改a=0,并且提交 回话一中再update这个字段a=0,会发现受影响行数是0,这样就可以根据受影响行数是0还是1判断此次修改是否成功！ 这在某些程序里会很有用！ 会话1: mysql> set autocommit=0; Query OK, 0 rows affected (0.00 sec) mysql> select * fro
事物隔离级别——不可重复读(Non-repeatable read)
YXX_decsdn的博客
06-08 1263
数据库事务隔离级别设置为READ-UNCOMMITTED（未提交读）并重启MySQL服务。 场景：Tom拿着工资卡去消费，酒足饭饱后在收银台买单，服务员告诉他本次消费1000元，Tom将银行卡给服务员，服务员将银行卡插入POS机，POS机读到卡里余额为3000元，就在Tom磨磨蹭蹭输入密码时，他老婆以迅雷不及掩耳盗铃之势把Tom工资卡的3000元转到自己账户并提交了事务，当Tom输完密码并点击“确...
mysql 事务 Repeatable Read
lwpoor123的博客
09-13 1063
脏读：读到别的事务没有提交的数据。 不可重复读：先前读取的数据，被别的事务改变了，再读就跟原来不一样了。 幻读：一个事务插入了某条数据，另一个事务去读插入的那条数据的时候发现没有，更新这条记录的时候又成功了，再次查询这条记录就出现了。
数据库学习笔记5-隔离级别 Repeatable Read
软件工程小施同学 的专栏
02-24 1031
1.Repeatable Read REPEATABLE READ避免了不可重复读问题，事务内对同一数据的多次读取都是一致的。 一个事务修改一条数据，其他事务修改同一数据就要等待。 增、删数据时会出现幻读。 不可重复读的重点是修改数据，幻读的重点是增删数据。 事务各自COMMIT后，再查询，各自的修改内容就汇总在一起了。 2.幻读（Phantom Read） 在Repeatable Read隔离级别下，一个事务可能会遇到幻读（Phantom Read）的问题。 幻读是指，在一个事务...
repeatable_read两个事物更新数据_数据库中事务隔离级别以及其实现简述
weixin_34264495的博客
01-12 702
首先我们要知道，数据库中的四基本特性（ACID）原子性。事务要么全执行要么全不执行。比如A打钱给B，大概分为两步走，A扣钱和B收钱， 打成功的话，钱从A的账户转移到B中，失败的话还是留在A的账户中，不会扣了A的钱而B没收到。一致性。指数据库事务不能破坏关系数据的完整性以及业务逻辑上的一致性，比如A：500 B：300这个一致性状态 在A给B转了200后变成A：200 B：500的这样另一个一致性状...
MySQL数据库——-事务的隔离级别（四）Repeatable read
paku-san的博客
06-08 974
文章目录2、Read committed（读提交）脏读不可重复读幻读 2、Read committed（读提交） 可以避免脏读，但可能出现不可重复读和幻读。 设置MySQL的事务隔离级别为REPEATABLE-READ 在my.ini配置文件最后加上如下配置，然后在服务中重启MySQL服务[mysqld] transaction-isolation = REPEATABLE-READ 查...
MySQL 的事务隔离级别是可重复读（Repeatable Read）
weixin_45724648的博客
12-07 475
在同一事务中进行多次查询时，会返回第一次查询时的快照，而不是实时的最新值。为了解决这个问题，您可以将事务隔离级别设置为读已提交（Read Committed），以确保每次查询都能读取到最新的数据。在 Spring Boot 中，可以使用。当您在同一个 Service 方法中执行了一个更新（update）操作，然后紧接着执行一个查询（select）操作时，
MySQL事务：REPEATABLE READ（可重读）隔离级别下 MVCC 如何工作？
学亮编程手记
11-27 734
SELECT：InnoDB 会根据以下条件检查每一行记录：第一，InnoDB 只查找版本早于当前事务版本的数据行，这样可以确保事务读取的行要么是在开始事务之前已经存在要么是事务自身插入或者修改过的。总结起来，REPEATABLE READ隔离级别下的MVCC机制通过创建事务开始时刻的快照和管理数据行的版本号，实现了可重复读取的一致性视图，避免了不可重复读和幻读问题。只有在快照创建之前已经提交的数据行版本才是可见的，未提交的版本和在快照创建之后产生的版本对于该事务是不可见的。
Mysql为何使用可重复读(Repeatable read)为默认隔离级别?
MG13138的博客
06-15 573
事务的特性(ACID) 群里有小伙伴面试时,碰到面试官提了个很刁钻的问题: Mysql为何使用可重复读(Repeatable read)为默认隔离级别??? 下面进入正题: 我们都知道事务的几种性质 :原子性、一致性、隔离性和持久性(ACID) 为了维持一致性和隔离性,一般使用加锁这种方式来处理,但是加锁相对带来的是并发处理能力的降低 而数据库是个高并发的应用,因此对于加锁的处理是事务的精髓. 下面我们来了解一下封锁协议,以及事务在数据库中做了什么 封锁协议（Locking Protoco.
repeatable_read两个事物更新数据_不要再说自己不会了 你值得阅读的Mysql事物学习笔记...
weixin_39783360的博客
01-17 323
前言在梳理 MySQL 事物和锁这一块知识的时候，发现其实自己了解的只是冰山一角，经过认真的查阅和研究之后，其实这一块的知识其实还真的有很多的学问。所以后面还是需要研读一下《高性能MySQL》这本书。正文谈到 MYSQL 的事物， 相信大家对这几个概念都不会陌生：四大特性：ACID并发问题脏读不可重复读幻读隔离级别Read Uncommitted（读未提交）Read Committed（读提交）R...
Mysql Innodb存储引擎的REPEATABLE-READ隔离级别到底有没有彻底解决幻读问题
提供各种学习资源及帮助
09-13 404
InnoDB中的REPEATABLE READ这种隔离级别通过临键锁+MVCC解决了大部分的幻读问题，但是并不是所有的幻读都能解读，想要彻底解决幻读，需要使用Serializable的隔离级别。RR中，通过间隙锁解决了部分当前读的幻读问题，通过增加间隙锁将记录之间的间隙锁住，避免新的数据插入。RR中，通过MVCC机制的，解决了快照读的幻读问题，RR中的快照读只有第一次会进行数据查询，后面都是直接读取快照，所以不会发生幻读。
6. 事务隔离级别之Repeatable Read
热门推荐
疯哥哥带你飞
03-20 1万+
接下来我们学习Mysql默认的事务隔离级别Repeatable Read，顾名思义，可重复读，也即在一个事务范围内相同的查询会返回相同的数据。延续上面的栗子：1. 小明很开心自己考了69分，于是他连接到数据库查询自己的成绩来炫耀给小伙伴，由于Repeatable Read是默认的事务隔离级别，因此这次他不需要进行修改：xiaoming&gt; select @@tx_isolation; +---...
mysql和oracle的事物_mysql和oracle默认的事物机制
weixin_39820136的博客
01-19 219
一、事务隔离级别ANSI/ISO SQL标准定义了4中事务隔离级别：未提交读(read uncommitted)，提交读(read committed)，重复读(repeatable read)，串行读(serializable)。对于不同的事务，采用不同的隔离级别分别有不同的结果。不同的隔离级别有不同的现象。主要有下面3种现在：1、脏读(dirty read)：一个事务可以读取另一个尚未提交事务...
MySQL可重复读应用场景_mysql-repeatable read 可重复读隔离级别-幻读实例场景
weixin_42398056的博客
01-19 1460
本文详解 repeatable read 可重复读 隔离级别产生的影响(幻读)-- SERIALIZABLE serializable 序列化 ；一个个事务排成序列的形式。事务一个挨一个执行，等待前一个事务执行完，后面的事务才可以顺序执行-- REPEATEABLE READ repeatable read 可重复读；安全上不如serializable，但是性能上比serializable强很多，...
mysql repeatable-read事务级别是使用事务级别快照吗
06-12
是的，MySQL中的REPEATABLE READ事务级别使用的是事务级别快照。在REPEATABLE READ事务级别下，MySQL会在事务开始时创建一个快照，该快照用于记录当前事务开始时数据库中所有数据的状态。在事务执行过程中，如果有其他事务对数据库进行了修改，则REPEATABLE READ事务级别下的事务不会看到这些修改，而是始终看到事务开始时的快照数据。 快照是通过MVCC技术实现的，MySQL会为每个事务分配一个唯一的事务ID（Transaction ID），并在每个数据行中记录该数据行最后一次修改的事务ID。在REPEATABLE READ事务级别下，事务只会看到在它开始之前已经提交的事务所做的修改，并通过快照机制来实现数据的一致性和隔离性。 因此，REPEATABLE READ事务级别使用的是事务级别快照，而不是行级快照。行级快照是在某个时间点对某些行进行备份，而事务级别快照是在事务开始时对整个数据库进行备份，用于实现REPEATABLE READ事务级别下的数据隔离。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值