1. IT分享知识网首页

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

老牧童 • • 未分类 • 阅读 114

如果没有有效的避免机制，就会出现以下几种问题：第一类丢失更新在完全未隔离事务的情况下，两个事务更新同一条数据资源，某一事务完成，另一事务异常终止

事务是现代关系型数据库的核心之一。在多个事务并发操作数据库（多线程、网络并发等）的时候，如果没有有效的避免机制，就会出现以下几种问题：

第一类丢失更新（Lost Update）

在完全未隔离事务的情况下，两个事务更新同一条数据资源，某一事务完成，另一事务异常终止，回滚造成第一个完成的更新也同时丢失 。这个问题现代关系型数据库已经不会发生，就不在这里占用篇幅，有兴趣的可以自行百度。

欢迎工作一到五年的Java工程师朋友们加入Java程序员开发： 854393687

群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）合理利用自己每一分每一秒的时间来学习提升自己，不要再用”没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！

脏读（Dirty Read）

A事务执行过程中，B事务读取了A事务的修改。但是由于某些原因，A事务可能没有完成提交，发生RollBack了操作，则B事务所读取的数据就会是不正确的。这个未提交数据就是脏读（Dirty Read）。脏读产生的流程如下：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

可以用EF Core模拟此过程：

class TestReadUncommitted :TestBase
 {
 private AutoResetEvent _autoResetEvent;
 [Test]
 public void ReadUncommitted()
 {
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"初始用户状态:【{user.Status}】");
 }
 _autoResetEvent = new AutoResetEvent(false);
 ThreadPool.QueueUserWorkItem(data =>{
 Write(); //启动线程写
 });
 ThreadPool.QueueUserWorkItem(data =>{
 Read(); //启动线程读
 });
 Thread.Sleep(5000);
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"最终用户状态:【{user.Status}】");
 }
 }
 private void Read()
 {
 _autoResetEvent.WaitOne();
 var options = new TransactionOptions { IsolationLevel = IsolationLevel.ReadUncommitted };
 using (var scope = new TransactionScope(TransactionScopeOption.Required, options))
 {
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务B：脏读到的用户状态:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 //如果这时执行下面的判断
 if (user.Status == 1)
 {
 Console.WriteLine("事务B：非正常数据，会产生意想不到的BUG");
 }
 }
 }
 }
 private void Write()
 {
 using (var scope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions {IsolationLevel = IsolationLevel.ReadCommitted}))
 {
 Console.WriteLine($"事务A：修改--{DateTime.Now.ToString("HH:mm:ss fff")}");
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 user.Status = 1-user.Status; //模拟修改
 context.SaveChanges();
 }
 _autoResetEvent.Set(); //模拟多线程切换，这时切换到Read线程，复现脏读
 Thread.Sleep(2000); //模拟长事务
 Console.WriteLine($"事务A：改完，但没提交--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 }
脏读示例

对应的执行结果：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

不可重复读（Nonrepeatable Read）

B事务读取了两次数据，在这两次的读取过程中A事务修改了数据，B事务的这两次读取出来的数据不一样。B事务这种读取的结果，即为不可重复读（Nonrepeatable Read）。不可重复读的产生的流程如下：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

模拟代码如下：

public class TestReadCommitted : TestBase
 {
 private AutoResetEvent _toWriteEvent = new AutoResetEvent(false);
 private AutoResetEvent _toReadEvent = new AutoResetEvent(false);
 [Test]
 public void ReadCommitted()
 {
 ThreadPool.QueueUserWorkItem(data => {
 Read(); //启动线程读
 });
 ThreadPool.QueueUserWorkItem(data => {
 Write(); //启动线程写
 });
 Thread.Sleep(5000);
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"最终用户状态:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 private void Read()
 {
 using (var transactionScope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }))
 {
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务B：第一次读取:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 _toWriteEvent.Set(); //模拟多线程切换，这时切换到写线程，复现不可重复读
 _toReadEvent.WaitOne();
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务B：第二次读取:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 }
 private void Write()
 {
 _toWriteEvent.WaitOne();
 using (var scope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }))
 {
 User user = null;
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务A：读取为【{user?.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 user.Status = 1 - user.Status;
 context.SaveChanges();
 }
 scope.Complete();
 Console.WriteLine($"事务A：已被更改为【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 _toReadEvent.Set();
 }
 }
 }
不可重复读示例

对应的执行结果：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

不可重复读有一种特殊情况，两个事务更新同一条数据资源，后完成的事务会造成先完成的事务更新丢失。这种情况就是大名鼎鼎的第二类丢失更新。主流的数据库已经默认屏蔽了第一类丢失更新问题（即：后做的事务撤销，发生回滚造成已完成事务的更新丢失），但我们编程的时候仍需要特别注意第二类丢失更新。它产生的流程如下：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

模拟代码如下：

public class TestReadCommitted2 : TestBase
 {
 private AutoResetEvent _toWriteEvent = new AutoResetEvent(false);
 private AutoResetEvent _toReadEvent = new AutoResetEvent(false);
 [Test]
 public void ReadCommitted()
 {
 ThreadPool.QueueUserWorkItem(data => {
 Read(); //启动线程读
 });
 ThreadPool.QueueUserWorkItem(data => {
 Write(); //启动线程写
 });
 Thread.Sleep(5000);
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"最终用户状态:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 private void Read()
 {
 using (var transactionScope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }))
 {
 User user = null;
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务B：第一次读取:【{user?.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 _toWriteEvent.Set(); //模拟多线程切换，这时切换到写线程，复现不可重复读
 _toReadEvent.WaitOne();
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务B：第二次读取:【{user?.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 user.Status = 1 - user.Status;
 context.SaveChanges();
 }
 transactionScope.Complete();
 Console.WriteLine($"事务B：已被更改为【{user?.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 private void Write()
 {
 _toWriteEvent.WaitOne();
 using (var scope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }))
 {
 User user = null;
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务A：读取为【{user?.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 user.Status = 1 - user.Status;
 context.SaveChanges();
 }
 scope.Complete();
 Console.WriteLine($"事务A：已被更改为【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 _toReadEvent.Set();
 }
 }
 }
第二类更新丢失示例

对应的执行结果如下图：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

可以明显看出事务A的更新被事务B所覆盖，更新丢失。

幻读（Phantom Read）

B事务读取了两次数据，在这两次的读取过程中A事务添加了数据，B事务的这两次读取出来的集合不一样。幻读产生的流程如下：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

这个流程看起来和不可重复读差不多，但幻读强调的集合的增减，而不是单独一条数据的修改。

模拟代码如下：

public class TestRepeat : TestBase
 {
 private AutoResetEvent _toWriteEvent = new AutoResetEvent(false);
 private AutoResetEvent _toReadEvent = new AutoResetEvent(false);
 [Test]
 public void Repeat()
 {
 ThreadPool.QueueUserWorkItem(data => {
 Read(); //启动线程读
 });
 ThreadPool.QueueUserWorkItem(data => {
 Write(); //启动线程写
 });
 Thread.Sleep(6000);
 }
 private void Read()
 {
 using (var transactionScope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.RepeatableRead }))
 {
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 Console.WriteLine($"事务B：第一次读取:【{context.Users.Count()}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 _toWriteEvent.Set(); //模拟多线程切换，这时切换到写线程，复现幻读
 _toReadEvent.WaitOne();
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 Console.WriteLine($"事务B：第二次读取:【{context.Users.Count()}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 }
 private void Write()
 {
 _toWriteEvent.WaitOne();
 using (var scope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted }))
 {
 Console.WriteLine($"事务A：新增一条--{DateTime.Now.ToString("HH:mm:ss fff")}");
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var id = GenerateId.ShortStr();
 context.Users.Add(new User { Id = id, Account = id, Status = 0, Name = id, CreateTime = DateTime.Now});
 context.SaveChanges();
 }
 scope.Complete();
 Console.WriteLine($"事务A：完成新增--{DateTime.Now.ToString("HH:mm:ss fff")}");
 _toReadEvent.Set();
 }
 }
 }
幻读示例

执行结果：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

数据库隔离级别

为了解决上面提及的并发问题，主流关系型数据库都会提供四种事务隔离级别。

读未提交（Read Uncommitted）

在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别是最低的隔离级别，虽然拥有超高的并发处理能力及很低的系统开销，但很少用于实际应用。因为采用这种隔离级别只能防止第一类更新丢失问题，不能解决脏读，不可重复读及幻读问题。

读已提交（Read Committed）

这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别可以防止脏读问题，但会出现不可重复读及幻读问题。

可重复读（Repeatable Read）

这是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发读取数据时，会看到同样的数据行。这种隔离级别可以防止除幻读外的其他问题。

可串行化（Serializable）

这是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读、第二类更新丢失问题。在这个级别，可以解决上面提到的所有并发问题，但可能导致大量的超时现象和锁竞争，通常数据库不会用这个隔离级别，我们需要其他的机制来解决这些问题:乐观锁和悲观锁。

这四种隔离级别会产生的问题如下（网上到处都有，懒得画了）：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

如何使用数据库的隔离级别

很多文章博客在介绍完这些隔离级别以后，就没有以后了。读的人一般会觉得，嗯，是这么回事，我知道了！

学习一个知识点，是需要实践的。比如下面这个常见而又异常严重的情况：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

图中是典型的第二类丢失更新问题，后果异常严重。我们这里就以读已提交（Read Committed）及以下隔离级别中会出现不可重复读现象为例。从上面的表格可以看出，当事务隔离级别为可重复读（Repeatable Read）时可以避免。把TestReadCommitted中的Read线程事务级别调整一下：

////////////////////////////////////////////////////////////////////////////////////////////////////
// file:	Test\TestReadCommitted.cs
//
// summary:	读已提交会出现“不可重复读”现象
// 把读线程（事务B）的隔离级别调整到RepeatableRead，即可杜绝
////////////////////////////////////////////////////////////////////////////////////////////////////
using System;
using System.Linq;
using System.Threading;
using System.Transactions;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using NUnit.Framework;
using TestTransaction.Domain;
namespace TestTransaction.Test
{
 public class TestReadCommitted : TestBase
 {
 private AutoResetEvent _toWriteEvent = new AutoResetEvent(false);
 private AutoResetEvent _toReadEvent = new AutoResetEvent(false);
 [Test]
 public void ReadCommitted()
 {
 ThreadPool.QueueUserWorkItem(data => {
 Read(); //启动线程读
 });
 ThreadPool.QueueUserWorkItem(data => {
 Write(); //启动线程写
 });
 Thread.Sleep(60000);
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"最终用户状态:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 private void Read()
 {
 //读线程（事务B）的隔离级别调整到RepeatableRead
 using (var transactionScope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.RepeatableRead, Timeout = TimeSpan.FromSeconds(40) }))
 {
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务B：第一次读取:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 _toWriteEvent.Set(); //模拟多线程切换，这时切换到写线程，复现不可重复读
 _toReadEvent.WaitOne();
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 var user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务B：第二次读取:【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 }
 private void Write()
 {
 _toWriteEvent.WaitOne();
 using (var scope = new TransactionScope(TransactionScopeOption.Required,
 new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted, Timeout = TimeSpan.FromSeconds(5) }))
 {
 User user = null;
 using (var context = _autofacServiceProvider.GetService<OpenAuthDBContext>())
 {
 user = context.Users.SingleOrDefault(u => u.Account == "admin");
 Console.WriteLine($"事务A：读取为【{user?.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 user.Status = 1 - user.Status;
 try
 {
 context.SaveChanges();
 scope.Complete();
 Console.WriteLine($"事务A：已被更改为【{user.Status}】--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 catch (DbUpdateException e)
 {
 Console.WriteLine($"事务A：异常，为了保证可重复读，你的修改提交失败，请稍后重试--{DateTime.Now.ToString("HH:mm:ss fff")}");
 }
 }
 _toReadEvent.Set();
 }
 }
 }
}

这时执行效果如下：

仅此一文让你明白事务隔离级别、脏读、不可重复读、幻读

实际项目中，通过提示客户端重做的方式，完美解决了不可重复读的问题。其他并发问题，也可以通过类似的方式解决

欢迎工作一到五年的Java工程师朋友们加入Java程序员开发： 854393687

群内提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）合理利用自己每一分每一秒的时间来学习提升自己，不要再用”没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！

免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://yundeesoft.com/55974.html

赞 (0)
老牧童老牧童
0

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注微信