事务的四种隔离级别（二）Read committed

最新推荐文章于 2024-08-11 21:41:16 发布
最新推荐文章于 2024-08-11 21:41:16 发布
阅读量1.2k 收藏 3
点赞数 1
文章标签： java 事务 隔离级别
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44829555/article/details/91344843
版权

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

首先设置MySQL事务隔离级别为Read committed

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

第一回：脏读

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

分析：两个并发的事务：“事务B：领导给Tom发工资”、“事务A：Tom查询工资账户”，事务隔离级别为READ-COMMITTED（读已提交）时事务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',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，这才平息了怒火；

结论：

事务隔离级别为Read committed时不会出现“脏读”

第二回：不可重复读

给出场景：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);

借助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就会提示余额不足，扣款失败！好尴尬。。。

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

第三回：幻读

场景：
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

结论：
事务隔离级别为Read committed时会出现“幻读”

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

事务隔离级别——Read uncommitted
我是真的囟的博客
06-10 3264
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。我们这篇博客主要来分析Read uncommitted 这种事务隔离级别。 一、修改MySQL数据库事务隔离级别。 在my.i...
事务隔离级别——READ-UNCOMMITTED（读未提交）
Zzze0101的博客
06-08 5581
首先，我们先设置MySQL事务隔离级别为Read uncommitted 在my.ini配置文件最后加上如下配置 #可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE. [mysqld] transaction-isolation = READ-UNCOMMITTED 重启MySQL服务 1、脏读 提...
事务隔离级别
最新发布
LHY537200的博客
08-11 1589
Spring 事务传播机制我们回顾一下MySQL 事务隔离级别.SQL 标准定义了四种隔离级别, MySQL 全都⽀持. 这四种隔离级别分别是:1.: 读未提交, 也叫未提交读. 该隔离级别的事务可以看到其他事务中未提交的数据.读已提交, 也叫提交读. 该隔离级别的事务能读取到已经提交事务的数据,该隔离级别不会有脏读的问题.但由于在事务的执⾏中可以读取到其他事务提交的结果, 所以在不同时间的相同 SQL 查询可能会得到不同的结果, 这种现象叫做不可重复读3.
MySQL数据库——-事务的隔离级别（二）Read uncommitted
paku-san的博客
06-08 543
1、Read uncommitted（读未提交） 可能出现脏读、不可重复读和幻读。JDBC具体代码举例： 场景：公司发工资了，领导把5000元打到Tom的账号上，但是该事务并未提交，而Tom正好去查看账户，发现工资已经到账，账户多了5000元，非常高兴，可是不幸的是，领导发现发给Tom的工资金额不对，是2000元，于是迅速回滚了事务，修改金额后，将事务提交，Tom再次查看账户时发现账户只多了...
事务隔离级别——REPEATABLE-READ（重复读）
Zzze0101的博客
06-08 7842
首先，我们先设置MySQL事务隔离级别为REPEATABLE-READ 在my.ini配置文件最后加上如下配置 #可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE. [mysqld] transaction-isolation = REPEATABLE-READ 重启MySQL服务 1、脏读 提出问...
MySql事务隔离
rclack的博客
02-06 642
（ACID）原子性、一致性、隔离性、持久性
5. 事务隔离级别之Read Committed
热门推荐
疯哥哥带你飞
03-20 2万+
这篇我们学习事务隔离级别Read Committed，顾名思义，就是读已提交，一个事务只能看到其他并发的已提交事务所作的修改。很显然，该级别可以解决Read Uncommitted中出现的“脏读“问题。除了Mysql，很多数据库都以Read Committed作为默认的事务隔离级别。下面通过例子来演示Read Committed解决“脏读”：1. 小明连接数据库去查询自己本学期的成绩，他设置ses...
事务隔离级别——Read committed
我是真的囟的博客
06-10 3066
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。我们这篇博客主要来分析Read committed 这种事务隔离级别。 一、修改MySQL数据库事务隔离级别。 在my.ini...
MySQL 四种事务隔离级别详解及对比
09-09
四种事务隔离级别分别是：未提交读（Read Uncommitted）、已提交读（Read Committed）、可重复读（Repeatable Read）以及串行化（Serializable）。每种级别的特性如下： 1. **未提交读（Read Uncommitted）**： 在...
通过实例分析MySQL中的四种事务隔离级别
09-09
SQL标准定义了四种不同的事务隔离级别，这些级别旨在处理并发操作时可能出现的问题，如脏读、不可重复读和幻读。MySQL作为广泛使用的数据库系统，支持这四种事务隔离级别。 1. **未提交读(Read Uncommitted)**：这...
MySQL的四种事务隔离级别
01-27
MySQL提供了四种事务隔离级别来处理这些问题： - 读未提交（READ UNCOMMITTED）：允许读取未提交的数据，可能导致脏读。 - 读已提交（READ COMMITTED）：只读取已提交的数据，避免脏读，但可能产生不可重复读。 - 可...
MySQL数据库——-事务的隔离级别（四）Repeatable read
paku-san的博客
06-08 1178
文章目录2、Read committed（读提交）脏读不可重复读幻读 2、Read committed（读提交） 可以避免脏读，但可能出现不可重复读和幻读。 设置MySQL的事务隔离级别为REPEATABLE-READ 在my.ini配置文件最后加上如下配置，然后在服务中重启MySQL服务[mysqld] transaction-isolation = REPEATABLE-READ 查...
MySQL__事务（Transaction）
Pinker_Q
09-25 1778
文章目录基本概念四大特性事务事务控制语句   基本概念 一个事务是一个完整的业务逻辑单元，不可再分！(比如银行转账，加钱和减钱同属一个业务逻辑单元 )   事务处理可以用来维护数据库的完整性，保证成批的 SQL 语句要么全部执行，要么全部不执行。   事务用来管理 insert,update,delete 语句（DML·）   四大特性 一般来说，事务是必须满足4个条件（ACID） 原子性（Atomicity，或称不可分割性）: 一个事务（transactio
Mysql.事务隔离级别(transaction_isolation)
newlife1441的博客
07-15 3605
MySQL有四种不同的隔离级别read-uncommit、read-commit、repeatable-read和serializable,这四种隔离级别分别解决了不同的数据一致性问题，也存在不同的问题，为了验证这些问题，我做了以下实验。
设置MySQL事务隔离级别 transaction_isolation
u010024893的专栏
01-08 6170
MySQL支持四种隔离级别，分别是： 0 --> 读未提交 1 --> 读已提交 2 --> 可重复读 3 --> 序列化 设置隔离级别的方法是： SET [SESSION|GLOBAL] transaction_isolation=[0|1|2|3]; 查看隔离级别的方法是： SHOW [GLOBAL] VARIABLES LIKE 'tran...
MySQL 常用配置变量-transaction_isolation
java_w的专栏
12-20 5972
transaction_isolation 设置隔离级别的参数： transaction_isolation='read-uncommitted|read-committed|repeatale-read|serializable'：默认是 repeatable-read，几个值分别代表的含义： read-uncommitted：读未提交，允许脏读； read-committed：读提交...
SET TRANSACTION ISOLATION LEVEL READ COMMITTED的作用（汇总自用）
JavaDaBaiCai的博客
06-02 850
（自用杂学）
mysql 查询、设置事务隔离级别 transaction_isolation
test
08-26 3903
参考https://jingyan.baidu.com/article/2f9b480d63f23c01ca6cc23d.html 其他参考资料： https://blog.csdn.net/java_w/article/details/103554447 https://www.cnblogs.com/hai-blog/p/8311687.html https://blog.csdn.net/L_15156024189/article/details/87006324 https://blo..
MySQL-事务隔离级别:READ UNCOMMITTED（未提交读）、READ COMMITTED（已提交读）、REPEATABLE READ（可重复读）、SERIALIZABLE（可串行化）
小孔靠得住的博客
03-07 3085
1、事务隔离级别:READ UNCOMMITTED（未提交读）、READ COMMITTED（已提交读）、REPEATABLE READ（可重复读）、SERIALIZABLE（可串行化） 2、​ InnoDB存储引擎在MySQL数据库中负责处理事务和行级锁定。Next-Key Lock是InnoDB为实现REPEATABLE READ隔离级别而采用的一种锁定机制，它结合了Record Lock（记录锁）和Gap Lock（间隙锁），旨在解决幻读问题。
MSSQL可否针对指定表设置事务隔离级别为 READ COMMITTED
06-01
是的，MSSQL可以针对指定的表设置事务隔离级别为 READ COMMITTED。在 MSSQL 中，可以使用以下两种方式来实现这个目的： 1. 使用表级别的锁提示 在 SQL 语句中，可以使用表级别的锁提示来指定事务隔离级别。例如，下面的 SQL 语句将会在 READ COMMITTED 隔离级别下锁定表 mytable： ``` SELECT * FROM mytable WITH (READCOMMITTED) ``` 2. 使用事务隔离级别提示 在 SQL 语句中，也可以使用事务隔离级别提示来指定事务隔离级别。例如，下面的 SQL 语句将会在 READ COMMITTED 隔离级别下启动事务： ``` SET TRANSACTION ISOLATION LEVEL READ COMMITTED BEGIN TRANSACTION -- 执行 SQL 语句 COMMIT TRANSACTION ``` 需要注意的是，如果在一个事务中同时涉及到多个表，那么这些表的事务隔离级别应该保持一致，否则可能会出现数据不一致的情况。同时，也需要根据具体的业务需求和场景来选择合适的事务隔离级别。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值