Entity Framework管理並發

Posted on by

理解並發

並發管理解決的是允許多個實體同時更新，實際上這意味著允許多個用戶同時在相同的數據上執行多個數據庫操作。並發是在一個數據庫上管理多個操作的一種方式，同時遵守瞭數據庫操作的ACID屬性（原子性、一致性、隔離性和持久性）。

想象一下下面幾種可能發生並發的場景：

1、用戶甲和乙都嘗試修改相同的實體。

2、用戶甲和乙都嘗試刪除相同的實體。

3、用戶甲正在嘗試修改一個實體時，用戶乙已經刪除瞭該實體。

4、用戶甲已經請求讀取一個實體，用戶乙讀完該實體之後更新瞭它。

這些場景可能會潛在地產生錯誤的數據，試想，成百上千的用戶同時嘗試操作一個相同的實體，這種並發問題將會對系統帶來更大的影響。

在處理與並發相關的問題時，一般有以下兩種方法：

1、樂觀並發：無論何時從數據庫請求數據，數據都會被讀取並保存到應用內存中。數據庫級別沒有放置任何顯示鎖。數據操作會按照數據層接收到的順序執行。

2、悲觀並發：無論何時從數據庫請求數據，數據都會被讀取，然後該數據上就會加鎖，因此沒有人能訪問該數據。這會降低並發相關問題的機率，缺點是加鎖是一個昂貴的操作，會降低整個應用程序的性能。

一、理解樂觀並發

前面提到，在樂觀並發中，無論何時從數據庫請求數據，數據都會被讀取並保存到應用內存中。數據庫級別沒有放置任何顯式鎖。因為這種方法沒有添加顯式鎖，所以比悲觀並發更具擴展性和靈活性。使用樂觀並發，重點是如果發生瞭任何沖突，應用程序要親自處理它們。最重要的是：使用樂觀並發控制時，在應用中要有一個沖突解決策略，要讓應用程序的用戶知道他們的修改是否因為沖突的緣故沒有持久化。樂觀並發本質上是允許沖突發生，然後以一種適當的方式解決該沖突。

下面是處理沖突的策略例子。

1、忽略沖突/強制更新

這種策略是讓所有的用戶更改相同的數據集，然後所有的修改都會經過數據庫，這就意味著數據庫會顯示最後一次更新的值。這種策略會導致潛在的數據丟失，因為許多用戶的更改數據都丟失瞭，隻有最後一個用戶的更改是可見的。

2、部分更新

在這種情況中，我們也允許所有的更改，但是不會更新完整的行，隻有特定用戶擁有的列更新瞭。這就意味著，如果兩個用戶更新相同的記錄但卻不同的列，那麼這兩個更新都會成功，而且來自這兩個用戶的更改都是可見的。

3、警告/詢問用戶

當一個用戶嘗試更新一個記錄時，但是該記錄自從他讀取之後已經被其他用戶更改瞭，這時應用程序就會警告該用戶該數據已經被其他用戶更改瞭，然後詢問他是否仍然要重寫該數據還是首先檢查已經更新的數據。

4、拒絕更改

當一個用戶嘗試更新一個記錄時，但是該記錄自從他讀取之後已經被其他用戶更改瞭，此時告訴該用戶不允許更新該數據，因為數據已經被其他用戶更新瞭。

二、理解悲觀並發

悲觀並發正好和樂觀並發相反，悲觀並發的目標是永遠不讓任何沖突發生。這是通過在使用記錄之前就在記錄上放置顯式鎖實現的。數據庫記錄上可以得到兩種類型的鎖：

隻讀鎖

更新鎖。

當把隻讀鎖放到記錄上時，應用程序隻能讀取該記錄。如果應用程序要更新該記錄，它必須要獲取到該記錄上的更新鎖。如果記錄上加瞭隻讀鎖，那麼該記錄仍然能夠被想要隻讀鎖的請求使用。然而，如果需要更新鎖，該請求必須等到所有的隻讀鎖釋放。同樣，如果記錄上加瞭更新鎖，那麼其他的請求不能再在這個記錄上加鎖，該請求必須等到已存在的更新鎖釋放才能加鎖。

從前面的描述中，似乎悲觀並發能解決所有跟並發相關的問題，因為我們不必在應用中處理這些問題。然而，事實上並不是這樣的。在使用悲觀並發管理之前，我們需要記住，使用悲觀並發有很多問題和開銷。下面是使用悲觀並發面臨的一些問題：

應用程序必須管理每個操作正在獲取的所有鎖。

加鎖機制的內存需求會降低應用性能。

多個請求互相等待需要的鎖，會增加死鎖的可能性。由於這些原因，EF不直接支持悲觀並發。如果想使用悲觀並發的話，我們可以自定義數據庫訪問代碼。此外，當使用悲觀並發時，LINQ to Entities不會正確工作。

三、使用EF實現樂觀並發

使用EF實現樂觀並發有很多方法，接下來我們就看一下這些方法。

1、新建控制臺項目，項目名：EFConcurrencyApp，新聞實體類定義如下：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EFConcurrencyApp.Model
{
    public class News
    {
        public int Id { get; set; }
        [MaxLength(100)]
        public string Title { get; set; }
        [MaxLength(30)]
        public string Author { get; set; }
        public string Content { get; set; }
        public DateTime CreateTime { get; set; }
        public decimal Amount { get; set; }

    }
}

2、使用數據遷移的方式生成數據庫，並填充種子數據。

namespace EFConcurrencyApp.Migrations
{
    using EFConcurrencyApp.Model;
    using System;
    using System.Data.Entity;
    using System.Data.Entity.Migrations;
    using System.Linq;

    internal sealed class Configuration : DbMigrationsConfiguration<EFConcurrencyApp.EF.EFDbContext>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = false;
        }

        protected override void Seed(EFConcurrencyApp.EF.EFDbContext context)
        {
            //  This method will be called after migrating to the latest version.

            //  You can use the DbSet<T>.AddOrUpdate() helper extension method
            //  to avoid creating duplicate seed data.

            context.News.AddOrUpdate(
                 new Model.News()
                 {
                     Title = "美國大城市房價太貴 年輕人靠“眾籌”買房",
                     Author = "佚名",
                     Content = "美國大城市房價太貴 年輕人靠“眾籌”買房",
                     CreateTime = DateTime.Now,
                     Amount = 0,
                 },
                 new Model.News()
                 {
                     Title = "血腥撲殺流浪狗太殘忍？那提高成本就是必須的代價",
                     Author = "佚名",
                     Content = "血腥撲殺流浪狗太殘忍？那提高成本就是必須的代價",
                     CreateTime = DateTime.Now,
                     Amount = 0,
                 },
                 new Model.News()
                 {
                     Title = "iPhone 8或9月6日發佈 售價或1100美元起",
                     Author = "網絡",
                     Content = "iPhone 8或9月6日發佈 售價或1100美元起",
                     CreateTime = DateTime.Now,
                     Amount = 0,
                 }
                 );
        }
    }
}

3、數據庫上下文定義如下

using EFConcurrencyApp.Model;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace EFConcurrencyApp.EF
{
    public class EFDbContext:DbContext
    {
        public EFDbContext()
            : base("name=AppConnection")
        {

        }

        public DbSet<News> News { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            // 設置表名和主鍵
            modelBuilder.Entity<News>().ToTable("News").HasKey(p => p.Id);
            base.OnModelCreating(modelBuilder);
        }
    }
}

4、實現EF的默認並發

先看一下EF默認是如何處理並發的，現在假設我們的應用程序要更新一個News的Amount值，那麼我們首先需要實現這兩個函數FindNews()和UpdateNews()，前者用於獲取指定的News，後者用於更新指定News。

Program類裡面定義的兩個方法如下：

static News FindNews(int id)
{
      using (var db = new EFDbContext())
      {
            return db.News.Find(id);
      }
}
static void UpdateNews(News news)
{
      using (var db = new EFDbContext())
      {
          db.Entry(news).State = EntityState.Modified;
          db.SaveChanges();
       }
}

下面我們實現這樣一個場景：有兩個用戶甲和乙都讀取瞭同一個News實體，然後這兩個用戶都嘗試更新這個實體的不同字段，比如甲更新Title字段，乙更新Author字段，代碼如下：

//1.用戶甲獲取id=1的新聞
var news1 = FindNews(1);
//2.用戶乙獲取id=1的新聞
var news2 = FindNews(1);
//3.用戶甲更新這個實體的新聞標題
news1.Title = news1.Title + "（更新）";
UpdateNews(news1);
//4.用戶乙更新這個實體的Amount
news2.Amount = 10m;
UpdateNews(news2);

上面的代碼嘗試模擬瞭一種並發問題。現在，甲和乙兩個用戶都有相同的數據副本，然後嘗試更新相同的記錄。執行代碼前，先看一下數據庫中的數據：

為瞭測試，在執行第四步時打一個斷點：

在斷點之後的代碼執行之前，去數據庫看一下數據，可以看到用戶甲的更新已經產生作用瞭：

繼續執行代碼，在看一下數據庫中的數據發生瞭什麼變化：

從上面的截圖可以看出，用戶乙的請求成功瞭，而用戶甲的更新丟失瞭。因此，從上面的代碼不難看出，如果我們使用EF更新整條數據，那麼最後一個請求總會獲得勝利，也就是說：最後一次請求的更新會覆蓋之前所有請求的更新。

四、設計處理字段級別並發的應用

接下來，我們會看到如何編寫處理字段級別並發問題的應用代碼。這是設計方式的應用思想是：隻有更新的字段才會在數據庫中進行更改。這樣就保證瞭如果多個用戶正在更新不同的字段，所有的更改都可以持久化到數據庫。

實現這個的關鍵是讓該應用識別用戶正在請求更新的所有列，然後為該用戶有選擇地更新那些字段。通過以下兩個方法來實現：

取數據的方法：該方法會給我們一個原始模型的克隆，隻有用戶請求的屬性會更新為新值。

更新的方法：它會檢查原始請求模型的哪個屬性值已經發生更改，然後在數據庫中隻更新那些值。

因此，首先需要創建一個簡單的方法，該方法需要模型屬性的值，然後會返回一個新的模型，該模型除瞭用戶嘗試更新的屬性以外，其他的屬性值都和原來的模型屬性值相同。方法定義如下：

static News GetUpdatedNews(int id, string title, string author, decimal amount, string content, DateTime createTime)
{
     return new News
     {
           Id = id,
           Title = title,
           Amount = amount,
           Author = author,
           Content = content,
           CreateTime = createTime,
      };
}

下一步，需要更改更新的方法。該更新方法會實現下面更新數據的算法：

1、根據Id從數據庫中檢索最新的模型值。

2、檢查原始模型和要更新的模型來找出更改屬性的列表。

3、隻更新步驟2中檢索到的模型發生變化的屬性。

4、保存更改。

更新方法定義如下：

static void UpdateNewsEnhanced(News originalNews, News newNews)
{
            using (var db = new EFDbContext())
            {
                //從數據庫中檢索最新的模型
                var news = db.News.Find(originalNews.Id);
                //接下來檢查用戶修改的每個屬性
                if (originalNews.Title != newNews.Title)
                {
                    //將新值更新到數據庫
                    news.Title = newNews.Title;
                }
                if (originalNews.Content != newNews.Content)
                {
                    //將新值更新到數據庫
                    news.Content = newNews.Content;
                }
                if (originalNews.CreateTime != newNews.CreateTime)
                {
                    //將新值更新到數據庫
                    news.CreateTime = newNews.CreateTime;
                }
                if (originalNews.Amount != newNews.Amount)
                {
                    //將新值更新到數據庫
                    news.Amount = newNews.Amount;
                }
                if (originalNews.Author != newNews.Author)
                {
                    //將新值更新到數據庫
                    news.Author = newNews.Author;
                }
                // 持久化到數據庫
                db.SaveChanges();
            }
}

運行代碼前，先查看數據庫中的數據：

然後執行主程序代碼，在執行第四步時打個斷點：

再次查看數據庫的數據，發現用戶甲的操作已經執行瞭：

繼續運行程序，再次查看數據庫的數據，發現用戶乙的操作也執行瞭：

從上面的截圖看到，兩個用戶請求同一個實體的更新值都持久化到瞭數據庫中。因此，如果用戶更新不同的字段，該程序可以有效地處理並發更新瞭。但是如果多個用戶同時更新相同的字段，那麼這種方法仍然顯示的是最後一次請求的值。雖然這種方式減少瞭一些並發相關的問題，但是這種方法意味著我們必須寫大量代碼來處理並發問題。後面我們會看到如何使用EF提供的機制來處理並發問題。

五、使用RowVersion實現並發

前面我們看到瞭EF默認如何處理並發（最後一次請求的數據更新成功），然後看到如果多個用戶嘗試更新不同的字段時，如何設計應用處理這些問題。接下來，我們看一下當多個用戶更新相同的字段時，使用EF如何處理字段級更新。

EF讓我們指定字段級並發，這樣如果一個用戶更新一個字段的同時，該字段已經被其他用戶更新過瞭，就會拋出一個並發相關的異常。使用這種方法，當多個用戶嘗試更新相同的字段時，我們就可以更有效地處理並發相關的問題。

如果我們為多個字段使用瞭特定字段的並發，那麼會降低應用性能，因為生成的SQL會更大，更加有效的方式就是使用RowVersion機制。RowVersion機制使用瞭一種數據庫功能，每當更新行的時候，就會創建一個新的行值。

給News實體類添加一個屬性：

1646474549
public byte[] RowVersion { get; set; }

在數據庫上下文中配置屬性：

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
      // 設置表名和主鍵
      modelBuilder.Entity<News>().ToTable("News").HasKey(p => p.Id);
      // 設置屬性
      modelBuilder.Entity<News>().Property(d => d.RowVersion).IsRowVersion();
      base.OnModelCreating(modelBuilder);
}

刪除原先的數據庫，然後重新生成數據庫，數據庫模式變為：

查看數據，RowVersion列顯示的是二進制數據：

現在EF就會為並發控制追蹤RowVersion列值。接下來嘗試更新不同的列：

using (var context = new EFDbContext())
{
                var news = context.News.SingleOrDefault(p => p.Id == 1);
                Console.WriteLine(string.Format("標題：{0} 打賞金額:{1} ", news.Title, news.Amount.ToString("C")));
                context.Database.ExecuteSqlCommand(@"update news set 
                        amount = 229.95 where Id = @p0", news.Id);
                news.Amount = 239.95M;
                Console.WriteLine(string.Format("標題：{0} 打賞金額:{1} ", news.Title, news.Amount.ToString("C")));
                context.SaveChanges();
}

運行程序，會拋出下面的異常：

從拋出的異常信息來看，很明顯是拋出瞭和並發相關的異常DbUpdateConcurrencyException，其他信息說明瞭自從實體加載以來，可能已經被修改或刪除瞭。

無論何時一個用戶嘗試更新一條已經被其他用戶更新的記錄，都會獲得異常DbUpdateConcurrencyException。

當實現並發時，我們總要編寫異常處理的代碼，給用戶展示一個更友好的描述信息。上面的代碼加上異常處理機制後修改如下：

using (var context = new EFDbContext())
{
      var news = context.News.SingleOrDefault(p => p.Id == 1);
      Console.WriteLine(string.Format("標題：{0} 打賞金額:{1} ", news.Title, news.Amount.ToString("C")));
      context.Database.ExecuteSqlCommand(string.Format(@"update News set 
                        Amount = 229.95 where Id = {0}", news.Id));
      news.Amount = 239.95M;
      Console.WriteLine(string.Format("標題：{0} 打賞金額:{1} ", news.Title, news.Amount.ToString("C")));

      try
      {
            context.SaveChanges();
      }
      catch (DbUpdateConcurrencyException ex)
      {
            Console.WriteLine(string.Format("並發異常:{0}", ex.Message));
      }
      catch (Exception ex)
      {
            Console.WriteLine(string.Format("普通異常:{0}", ex.Message));
      }
}

此時，我們應該使用當前的數據庫值更新數據，然後重新更改。作為開發者，如果我們想要協助用戶的話，我們可以使用EF的DbEntityEntry類獲取當前的數據庫值。

using (var context = new EFDbContext())
{
      var news = context.News.SingleOrDefault(p => p.Id == 1);
      Console.WriteLine(string.Format("標題：{0} 打賞金額:{1} ", news.Title, news.Amount.ToString("C")));
              
context.Database.ExecuteSqlCommand(string.Format(@"update News set 
       Amount = 229.95 where Id = {0}", news.Id));
       news.Amount = 239.95M;
       Console.WriteLine(string.Format("標題：{0} 打賞金額:{1} ", news.Title, news.Amount.ToString("C")));       try
       {
         context.SaveChanges();
       }
       catch (DbUpdateConcurrencyException ex)
       {
          // 使用這段代碼會將Amount更新為239.95
          var postEntry = context.Entry(news);
          postEntry.OriginalValues.SetValues(postEntry.GetDatabaseValues());
          context.SaveChanges();
        }
        catch (Exception ex)
        {
           Console.WriteLine(string.Format("普通異常:{0}", ex.Message));
        }
}

示例代碼下載地址：點此下載

到此這篇關於Entity Framework管理並發的文章就介紹到這瞭。希望對大傢的學習有所幫助，也希望大傢多多支持WalkonNet。

推薦閱讀：