事务的四种隔离级别（三）REPEATABLE-READ

最新推荐文章于 2023-05-12 17:12:47 发布
最新推荐文章于 2023-05-12 17:12:47 发布
阅读量618 收藏
点赞数
文章标签： java 数据库 事务 隔离级别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44829555/article/details/91344850
版权

上回书说到，当事务的隔离级别为Read committed时会出现的乌龙，这一回我们就聊聊隔离级别为REPEATABLE-READ时的情况

首先设置MySQL事务隔离级别为REPEATABLE-READ

方法：
在my.ini配置文件最后加上如下配置
[mysqld] transaction-isolation = REPEATABLE-READ
然后重启MySQL服务；

第一回：脏读

场景：公司发工资了，领导把5000元打到Tom的账号上，但是该事务并未提交，而Tom正好去查看账户，发现工资已经到账，账户多了5000元，非常高兴，可是不幸的是，领导发现发给Tom的工资金额不对，是2000元，于是迅速回滚了事务，修改金额后，将事务提交，Tom再次查看账户时发现账户只多了2000元，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);

借助java代码来还原这个过程

发工资的：

import java.sql.*;

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 {
			//释放资源
		}
	}
}

收钱的人：

import java.sql.*;

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方法，发现查询到结果为0（老板这王八蛋不是说发工资么），冷静思考10s后再次执行Employye类中main方法，发现多了2000.0

结论：

事务隔离级别为REPEATABLE-READ时不会出现“脏读”

第二回：不可重复读

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

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

先建表

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);

借助java代码还原这个过程：

pos机

import java.sql.*;

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 {
			//释放资源
		}
	}
}

老婆

import java.sql.*;

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方法输出

执行结果：
执行Machine类中main方法后，查询到余额确实为3000；再执行Wife类中main方法，会输出转账成功；观察Machine类中main方法输出，等待10s就会提示余额3000.0，扣款失败；（到底亏的是谁）

结论：
事务隔离级别为REPEATABLE-READ时不会出现“不可重复读”

第三回：幻读

场景：
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：添加了新的消费记录”，事务A获取事务B消费记录时数据多出了一条。

借助java代码来还原这个过程

查账的：

import java.sql.*;

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(10000);//10秒后查询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 {
			//释放资源
		}
	}
}

花钱的：

import java.sql.*;

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方法——>再执行Husband类中main方法——>观察Bank类中main方法输出

执行结果：
执行Bank类中main方法后立即执行Husband类中main方法，输出结果确实是80.0刀，等待10s后输出结果为37.0，43.0 ，1000.0

结论：
事务隔离级别为REPEATABLE-READ时会出现“幻读”

欲知后事如何，且听下回分解
事务的四种隔离级别（四）REPEATABLE-READ

中单亚索不给就送
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面试问烂的 MySQL 四种隔离级别，看完吊打面试官！
犬小哈
08-05 216
点击上方“小哈学Java”，选择“星标”回复“666”，领取100G独家整理的学习资料哟~来源：http://1t.click/6pc什么是事务事务是应用程序中一系列严密...
Spring事务配置隔离级别Isolation.READ_COMMITTED引发的一系列问题
热门推荐
davenTsang的专栏
06-08 2万+
这两天改了下spring事务隔离级别，使用Isolation.READ_COMMITTED,导致了放到生产环境马上出现错误。这是在测试环境没有的，找log发现了：Caused by: java.sql.SQLException: Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = ST...
Mysql.事务隔离级别(transaction_isolation)
newlife1441的博客
07-15 3501
MySQL有四种不同的隔离级别read-uncommit、read-commit、repeatable-read和serializable,这四种隔离级别分别解决了不同的数据一致性问题，也存在不同的问题，为了验证这些问题，我做了以下实验。
MySql事务隔离
rclack的博客
02-06 568
（ACID）原子性、一致性、隔离性、持久性
Spring——事务控制
Paranoidse的博客
05-01 418
Spring事务控制： 1、JavaEE 体系进行分层开发,事务处理位于业务层,Spring提供了分层设计业务层的事务处理解决方 案 2、Spring 框架为我们提供了一组事务控制的接口,这组接口在spring-tx-5.0.2.RELEASE.jar中 3、Spring 的事务控制都是基于AOP的,它既可以使用配置的方式实现,也可以使用编程的方式实现.推荐使用配置方式实现. 数据库事务的...
浅析MYSQL REPEATABLE-READ隔离级别
01-19
REPEATABLE-READ 即可重复读，set autocommit= 0或者START TRANSACTION状态下select表的内容不会改变。这种隔离级别可能导致读到的东西是已经修改过的。 比如: 回话一中读取一个字段一行a=1 在回话二里这个字段该行...
MySQL的四种事务隔离级别
01-27
MySQL提供了四种事务隔离级别来处理这些问题： - 读未提交（READ UNCOMMITTED）：允许读取未提交的数据，可能导致脏读。 - 读已提交（READ COMMITTED）：只读取已提交的数据，避免脏读，但可能产生不可重复读。 - 可...
深入理解Mysql的四种隔离级别
09-09
MySQL提供了四种不同的事务隔离级别，每种级别在处理并发操作时有着不同的策略，以平衡数据一致性与系统性能。让我们逐一深入理解这些隔离级别。 1. **原子性（Atomicity）**：事务的最基本特性，确保事务中的所有...
MySQL 四种事务隔离级别详解及对比
09-09
四种事务隔离级别分别是：未提交读（Read Uncommitted）、已提交读（Read Committed）、可重复读（Repeatable Read）以及串行化（Serializable）。每种级别的特性如下： 1. **未提交读（Read Uncommitted）**： 在...
Spring事务隔离级别与传播行为
l_learning的博客
05-16 1723
org.springframework.transaction public interface TransactionDefinition 定义符合 Spring 的事务属性的接口。基于类似于 EJB CMT 属性的传播行为定义。‎ ‎注意，除非启动实际的新事务，否则不会应用隔离级别和超时设置。‎ ‎仅‎ PROPAGATION_REQUIRED, PROPAGATION_REQUIRES_NEW and PROPAGATION_NESTED ‎可能导致这种情况，在其他情况下指定这些设置通常没有意义。此外
mysql的读已提交和可重复读（Read Committed和Repeatable Read隔离级别）
堡望的博客
06-27 1万+
共享锁和排他锁 READ-COMMITTED读已提交 REPEATABLE-READ可重复读
Read Committed 为什么不能防止不可重复读现象
Lucky小黄人的博客
04-17 1213
我们都知道MySQL 数组库有四大事务隔离级别，分别是未提交读(Read Uncommitted)、提交读(Read Committed)、可重复度(Repeatable Read)、可串行化(SERIALIZABLE). 其中每个隔离级别有不同的特性 未提交读可能会导致脏读，不可重复度和幻读问题。 提交读因为只能读取已经提交的数据，所以可以避免脏读，但是不保证事务重新读的时候能读到相同的数据，...
mysql5.7性能提升一百倍调优宝典
lifetragedy的专栏
05-06 1万+
全文中一共有常用的（事实上你如果花1-2周阅读、理解、自己动手设一下后是需要这么多参数的）76个参数，我是按照： 每一个参数干吗？ 在某些典型硬件配置下的db上参数该设多少？ 设会怎么样？ 不设会怎么样？ 有什么坑如何填坑？ 有些参数怎么算、算法又如何 这种style来写的，具体请看文档！ 一千个DBA就有一千种配置方式! 大家一定记得不要轻易去看网上，要看只看官网！网上很多博客都...
mysql 数据库事务 （二）隔离级别
Sucker的小笔记
12-07 296
属于事务四大特性之一的隔离性(isolation)，解决两个并发事务同时访问数据库表相同的行时，可能存在的问题 基础 四大隔离级别 1、 read uncommitted（读未提交） - 事务A和事务B，事务A未提交的数据，事务B可以读取到 - 这里读取到的数据叫做“脏数据” - 这种隔离级别最低，这种级别一般是在理论上存在，数据库隔离级别一般都高于该级别 问题：引发脏读; 原因：读取了未提交的数据 1 脏读 　　脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。 　　当一个..
数据库事物隔离级别
尽量致力于发表微服务、中间件和算法等原创作品。
01-17 2692
数据库事务的隔离级别有4个，由低到高依次为Read uncommitted（读未提交） 、Read committed（读已提交） 、Repeatable read（重复读） 、Serializable（序列化） ，这四个级别可以逐个解决脏读 、不可重复读 、幻读这几类问题。而事务1，继续执行在旧版本的数据上。整个事务过程中，对同一笔数据的读取结果是相同的，不管其他事务是否在对共享数据进行更新，也不管更新提交与否。一个事务的更新操作结果只有在该事务提交之后，另一个事务才可以的读取到同一笔数据更新后的结果。
@Transactional事务的传播行为和隔离级别
weixin_38417148的博客
05-12 1741
事务传播行为和隔离级别
READ COMMITTED和REPEATABLE READ的区别
罗兰娇的博客
02-13 3001
一.概要 总结：REPEATABLE READ是在READ COMMITTED的基础上，限制事务自身不受到外部影响（不管途中其他事务是否commit更改操作），对数据的查询结果始终与本身事务的操作结果一致。 二.实验记录 示例环境：docker中的mysql 容器(Navicat Premium命令界面，如果用xshall命令打开docker连接使用的话，没有可重复读的效果) 以book表为共...
深入理解MySQL事务隔离级别Read Commited
weixin_40903413的博客
09-16 639
本文通过一个集体的例子，一文完成深入理解。这个版本是RC事务中通常的操作顺序即：“读 - 写 - 写”，可以避免第一版中“写 - 读 - 写”的可见性问题，但是问题仍然是存在的，即并发写入场景会由于唯一索引冲突引发事务回滚，那么有没有更好的写法呢？总结一下，对于RC事务隔离级别会出现幻读和不可重复读的问题，通常在RC事务中应当遵循“读 - 写 - 写”的执行顺序，但是基于业务场景的分析通常可以做到更好的性能提升。是可见的，这样表设计的唯一索引也失效了，导致了同一个订单号，两个有效批次的插入。
MySQL———事物（Transaction）
Vicali的博客
12-01 1434
一、什么是事物 事物：一个最小的不可分割的工作单元。（例：银行转账业务） 原子操作是对一个单一的对象（包括类域、数组元素等永久对象）数据进行修改过程中发生断电、严重异常等失败情况时，保证原始数据的完整性，即恢复到初始数据状态。事务操作是对一系列的永久数据更新的一个逻辑的集合，要么所有的永久数据的修改都正确完成，要么所有的数据都被恢复为它们以前的值。 银行账户表 tb_act actno balance 1 500 2 100 转账操作
mysql repeatable-read事务级别是使用事务级别快照吗
最新发布
06-12
是的，MySQL中的REPEATABLE READ事务级别使用的是事务级别快照。...行级快照是在某个时间点对某些行进行备份，而事务级别快照是在事务开始时对整个数据库进行备份，用于实现REPEATABLE READ事务级别下的数据隔离。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值