事务隔离级别——READ-COMMITTED（读已提交）

最新推荐文章于 2024-10-06 19:35:38 发布
最新推荐文章于 2024-10-06 19:35:38 发布
阅读量3.1w 收藏 48
点赞数 22
分类专栏： 数据库 事务 文章标签： 事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zzze0101/article/details/91344710
版权

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

  1. 在my.ini配置文件最后加上如下配置
#可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE.
[mysqld]
transaction-isolation = READ-COMMITTED
  1. 重启MySQL服务

1、脏读

提出问题
同一个应用程序中的多个事务或不同应用程序中的多个事务在同一个数据集上并发执行时, 可能会出现许多意外的问题。
例如： 已知有两个事务A和B, B读取了已经被A更新但还没有被提交的数据，之后，A回滚事务，B读取的数据就是脏数据。
场景：
Tom的账户money=0，公司发工资把5000元打到Tom的账户上，Tom的money=money+5000元，但是该事务并未提交，而Tom正好去查看账户，发现工资已经到账，账户money=5000元，非常高兴，可是不幸的是，公司发现发给Tom的工资金额不对，应该是2000元，于是迅速回滚了事务，修改金额后，将事务提交，Tom再次查看账户时发现账户money=2000元，Tom空欢喜一场，从此郁郁寡欢，走上了不归路……
当我们设置事务隔离级别为READ-COMMITTED（读已提交）时事务流程如下：

事务A（代表公司）事务B（代表Tom）
read（money）；
money=money+5000；
write（money）
read（money）；（读已提交数据）
…
rollback；（money=0）
money=money+2000
submit ；
read（money）；（读已提交数据）

分析：上述情况即为脏读，两个并发的事务：“事务A：公司给Tom发工资”、“事务B：Tom查询工资账户”，事务隔离级别为READ-COMMITTED（读已提交）时事务B只会读取已提交的数据。
实验
我们在java代码中观察这种情况：

public class Boss {//公司给Tom发工资

	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 money=money+5000 where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			Thread.sleep(10000);//10秒后发现工资发错了
			connection.rollback();
			sql = "update account set money=money+2000 where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			connection.commit();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}
public class Employee {//Tom查询余额

	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方法后立即执行Employee中的main方法得：
在这里插入图片描述
在执行Boss中main方法后等待10秒，执行Employee中的main方法得：
在这里插入图片描述
得出结论
事务隔离级别为READ-COMMITTED（读已提交）时不会出现“脏读”

2、不可重复读

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

事务A（代表POS机）事务B（代表老婆）
read（money）；
输入密码read（money）；
…money=money-3000；（转账）
…write（money）；submit ；
read（money）；
余额不足！

分析：上述情况即为不可重复读，两个并发的事务，“事务A：POS机扣款”、“事务B：Tom的老婆网上转账”，事务A事先读取了数据，事务B紧接了更新数据并提交了事务，而事务A再次读取该数据扣款时，数据已经发生了改变。
实验
我们在java代码中观察这种情况：

public class Machine {//POS机扣款

	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 money from account where card_id='6226090219290000'";
			resultSet = statement.executeQuery(sql);
			if(resultSet.next()) {
				System.out.println("余额："+resultSet.getDouble("money"));
			}
			
			System.out.println("请输入支付密码：");
			Thread.sleep(10000);//10秒后密码输入成功
			
			resultSet = statement.executeQuery(sql);
			if(resultSet.next()) {
				double money = resultSet.getDouble("money");
				System.out.println("余额："+money);
				if(money<sum) {
					System.out.println("余额不足，扣款失败！");
					return;
				}
			}
			
			sql = "update account set money=money-"+sum+" where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			connection.commit();
			System.out.println("扣款成功！");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}
public class Wife {//Tom的老婆网上转账

	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 money=money-"+money+" where card_id='6226090219290000'";
			statement.executeUpdate(sql);
			sql = "update account set money=money+"+money+" where card_id='6226090219299999'";
			statement.executeUpdate(sql);
			connection.commit();
			System.out.println("转账成功");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//释放资源
		}
	}
}

在执行Machine中main方法后立即执行Wife中的main方法得：

在这里插入图片描述
等待10秒后Machine中main方法执行结果：
在这里插入图片描述

得出结论
事务隔离级别为READ-COMMITTED（读已提交）时会出现“不可重复读”。

3、幻读

幻读(Phantom Read): 已知有两个事务A和B，A从一个表中读取了数据，然后B在该表中插入了一些新数据，导致A再次读取同一个表, 就会多出几行。
提出问题
场景：Tom的老婆工作在银行部门，她时常通过银行内部系统查看Tom的工资卡消费记录。2019年5月的某一天，她查询到Tom当月工资卡的总消费额为80元，Tom的老婆非常吃惊，心想“老公真是太节俭了，嫁给他真好！”，而Tom此时正好在外面胡吃海塞后在收银台买单，消费1000元，即新增了一条1000元的消费记录并提交了事务，沉浸在幸福中的老婆查询了Tom当月工资卡消费明细一探究竟，可查出的结果竟然发现有一笔1000元的消费，Tom的老婆瞬间怒气冲天，外卖订购了一个大号的榴莲，傍晚降临，Tom生活在了水深火热之中，只感到膝盖针扎的痛…
当我们设置事务隔离级别为READ-COMMITTED（读已提交）时事务流程如下：

事务A（代表老婆）事务B（代表Tom消费）
read（消费记录）；
消费金额80元read（money）；
…money=money-1000；（消费）
…write（money）；submit ；
read（消费记录）；
消费金额1080元

分析：上述情况即为幻读，两个并发的事务，“事务A：获取事务B消费记录”、“事务B：添加了新的消费记录”，事务A获取事务B消费记录时数据多出了一条。
实验
我们在java代码中观察这种情况：

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);//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 {//Tom消费1000元

	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 money=money-"+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方法后立即执行Wife中的Husband方法得：
在这里插入图片描述
等待10秒后控制台输出：在这里插入图片描述
得出结论
事务隔离级别为READ-COMMITTED（读已提交）时会出现“幻读”

所用表

create table account(
	id int(36) primary key comment '主键',
  	card_id varchar(16) unique comment '卡号',
  	name varchar(8) not null comment '姓名',
  	money float(10,2) default 0 comment '余额'
)engine=innodb;
insert into account (id,card_id,name,money) 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');
Zzze0101
关注
专栏目录
事务隔离级别——Read uncommitted
我是真的囟的博客
06-10 3267
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。我们这篇博客主要来分析Read uncommitted 这种事务隔离级别。 一、修改MySQL数据库事务隔离级别。 在my.i...
事务隔离级别——READ-UNCOMMITTED（读未提交）
Zzze0101的博客
06-08 5589
首先，我们先设置MySQL事务隔离级别为Read uncommitted 在my.ini配置文件最后加上如下配置 #可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE. [mysqld] transaction-isolation = READ-UNCOMMITTED 重启MySQL服务 1、脏读 提...
【MySQL】事务
Java领域
01-13 1170
事务是一组操作的集合，他是一个不可分割的工作单位，事务会把所有的操作作为也给整体一起向整体提交或撤销请求，即这些操作要么成功要么失败。默认mysql的事务时自动给提交的，也就是当执行一条DML语句，MySQL会立即隐式的提交事务比如：在银行转账中，张三原本有2000元，李四原本有2000元，张三要给李四转账1000元，在张三转账完成时系统发生故障，这1000块钱到不了李四的账户上，那么张三的1000元应该返回到张三账户，这个现象就可以使用事务。
脏读、不可重复读、幻读的解决方法
最新发布
qq_71416673的博客
10-06 1077
上一篇博客提到了脏读、不可重复读、幻读的含义，也知道了是因为什么情况导致出现的这些问题，这篇博客就带大家一起来了解一下他们的解决办法~：脏读出现的原因主要是因为一个事务读取了另外一个事务未提交的数据，就可能出现脏读，解决办法可以通过“读已提交”这种形式进行解决。
关系型数据库事务的隔离级别： 读未提交, 读已提交, 可重复读, 序列化。
kfepiza的博客
02-25 1121
事务的四性: 原子性，一致性，隔离性，持久性。(4项)事务的隔离级别： 读未提交, 读已提交, 可重复读, 序列化。(4项)并发事务可能引起: 脏读, 不可重复读, 幻读。(3项)读未提交不能防止 脏读, 不可重复读, 幻读;读已提交级别:可防止脏读。可重复读级别:可防止脏读,不可重复读。序列化级别,并发事务只能逐个执行：脏读，不可重复读，幻读，都可以防止。关系型数据库事务的隔离级别是指在并发境下，事务之间相互隔离的程度。
MySQL数据库——-事务的隔离级别（二）Read uncommitted
paku-san的博客
06-08 544
1、Read uncommitted（读未提交） 可能出现脏读、不可重复读和幻读。JDBC具体代码举例： 场景：公司发工资了，领导把5000元打到Tom的账号上，但是该事务并未提交，而Tom正好去查看账户，发现工资已经到账，账户多了5000元，非常高兴，可是不幸的是，领导发现发给Tom的工资金额不对，是2000元，于是迅速回滚了事务，修改金额后，将事务提交，Tom再次查看账户时发现账户只多了...
事务的四种隔离级别（二）Read committed
qq_44829555的博客
06-08 1271
aaa
MySQL-事务隔离级别:READ UNCOMMITTED（未提交读）、READ COMMITTED（已提交读）、REPEATABLE READ（可重复读）、SERIALIZABLE（可串行化）
小孔靠得住的博客
03-07 3111
1、事务隔离级别:READ UNCOMMITTED（未提交读）、READ COMMITTED（已提交读）、REPEATABLE READ（可重复读）、SERIALIZABLE（可串行化） 2、​ InnoDB存储引擎在MySQL数据库中负责处理事务和行级锁定。Next-Key Lock是InnoDB为实现REPEATABLE READ隔离级别而采用的一种锁定机制，它结合了Record Lock（记录锁）和Gap Lock（间隙锁），旨在解决幻读问题。
mysql事务之提交读(Read Committed)
Mergades
03-29 2万+
1，Read Commited定义： 在提交读(READ COMMITTED)级别中，基于锁机制并发控制的DBMS需要对选定对象的写锁(write locks)一直保持到事务结束，但是读锁(read locks)在SELECT操作完成后马上释放（因此“不可重复读”现象可能会发生，见下面描述）。和前一种隔离级别一样，也不要求“范围锁(range-locks)”。 简而言之，提交读这种隔离级别保证了...
5. 事务隔离级别之Read Committed
热门推荐
疯哥哥带你飞
03-20 2万+
这篇我们学习事务隔离级别Read Committed，顾名思义，就是读已提交，一个事务只能看到其他并发的已提交事务所作的修改。很显然，该级别可以解决Read Uncommitted中出现的“脏读“问题。除了Mysql，很多数据库都以Read Committed作为默认的事务隔离级别。下面通过例子来演示Read Committed解决“脏读”：1. 小明连接数据库去查询自己本学期的成绩，他设置ses...
MySQL事务隔离级别----Read committed（读已提交）
My_liuying0901
07-14 1万+
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。数据库不同，其支持的事务隔离级别亦不相同：MySQL数据库支持上面四种事务隔离级别，默认为Repeatable read；Oracle 数...
事务隔离级别——Read committed
我是真的囟的博客
06-10 3067
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。我们这篇博客主要来分析Read committed 这种事务隔离级别。 一、修改MySQL数据库事务隔离级别。 在my.ini...
事务隔离级别——REPEATABLE-READ（重复读）
Zzze0101的博客
06-08 7852
首先，我们先设置MySQL事务隔离级别为REPEATABLE-READ 在my.ini配置文件最后加上如下配置 #可选参数有：READ-UNCOMMITTED, READ-COMMITTED, REPEATABLE-READ, SERIALIZABLE. [mysqld] transaction-isolation = REPEATABLE-READ 重启MySQL服务 1、脏读 提出问...
事务隔离级别——未提交读、已提交读、可重复读、串行
weixin_42440637的博客
02-01 2887
事务隔离级别——未提交读、已提交读、可重复读、串行 事务隔离级别是指多个事务之间，不同事务中涉及的读写操作互相影响的隔离。其中多个事务中同时对同一条数据或者表进行写操作(insert、update、delete)，必定会导致事务间数据的相互影响，导致不可预知问题发生。主要的问题可以归为以下几种： 脏读——A事务读取B事务尚未提交的数据，此时如果B事务发生错误并执行回滚操作，那么A事务读取到的数据就是脏数据。 不可重复读——事务A在执行读取操作，由整个事务A比较大，前后读取同一条数据需要经历很长的时间 。而
Read Committed
unber的博客
11-30 749
在Read Committed隔离级别下，一个事务可能会遇到不可重复读（Non Repeatable Read）的问题。
MySQL事务隔离级别----Read uncommitted（读未提交）
My_liuying0901
07-14 1393
根据实际需求，通过设置数据库的事务隔离级别可以解决多个事务并发情况下出现的脏读、不可重复读和幻读问题，数据库事务隔离级别由低到高依次为Read uncommitted、Read committed、Repeatable read和Serializable等四种。数据库不同，其支持的事务隔离级别亦不相同：MySQL数据库支持上面四种事务隔离级别，默认为Repeatable read；Oracle 数...
Jira的 Transaction level 'READ-COMMITTED' in InnoDB is not safe for binlog mode 'STATEMENT'错误的解决
applebomb的专栏
01-22 3330
Jira的 Transaction level 'READ-COMMITTED' in InnoDB is not safe for binlog mode 'STATEMENT'错误的解决
mysql read committed
zhaoyangjian724的专栏
11-09 1101
read commit;Oracle采用的也是 read committed默认是:mysql> SELECT @@GLOBAL.tx_isolation, @@tx_isolation; +———————–+—————–+ | @@GLOBAL.tx_isolation | @@tx_isolation | +———————–+—————–+ | REPEATABLE-READ
MySQL中readcommitted_数据库事务隔离级别：Read uncommitted 、Read committed 、Rep... - 简书...
weixin_33109551的博客
02-02 1353
1.数据库事务隔离级别数据库事务的隔离级别有4个，由低到高依次为Read uncommitted 、Read committed 、Repeatable read 、Serializable ，后面三个级别可以逐个解决脏读 不可重复读 、幻读 这几类问题。2.总结1> 脏读：当事务隔离级别为read uncommitted，则可以读到其他事务未提交的数据，这是所有隔离级别中最低的一种。此时的...
如何将MSSQL事务隔离级别设置为 READ COMMITTED
06-01
可以使用以下SQL语句将MSSQL事务隔离级别设置为 READ COMMITTED： ``` SET TRANSACTION ISOLATION LEVEL READ COMMITTED ``` 执行以上语句后，该事务的隔离级别将会被设置为 READ COMMITTED，即在该事务中， SELECT 查询操作只能读取已提交的数据，而不能读取到未提交的数据或者已提交但未被该事务锁定的数据。 需要注意的是，该语句只对当前的事务有效，如果需要设置所有连接的默认隔离级别为 READ COMMITTED，可以使用以下语句： ``` ALTER DATABASE [数据库名称] SET READ_COMMITTED_SNAPSHOT ON ``` 执行以上语句后，该数据库的默认隔离级别将被设置为 READ COMMITTED。需要注意的是，该语句会开启快照隔离模式，会增加数据库的存储空间和性能开销，因此需要根据具体的业务场景和需求进行选择。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值