使用乐观并发方法处理多个生产者插入的唯一“不可变”实体的有效方法是什么？

Question

假设一个系统有多个并发生产者，每个生产者都努力保留一些对象图，其中包含以下可通过名称唯一标识的公共实体：

CREATE TABLE CommonEntityGroup(
    Id INT NOT NULL IDENTITY(1, 1) PRIMARY KEY,
    Name NVARCHAR(100) NOT NULL
);
GO

CREATE UNIQUE INDEX IX_CommonEntityGroup_Name 
    ON CommonEntityGroup(Name)
GO


CREATE TABLE CommonEntity(
    Id INT NOT NULL IDENTITY(1, 1) PRIMARY KEY,
    Name NVARCHAR(100) NOT NULL,
    CommonEntityGroupId INT NOT NULL,
    CONSTRAINT FK_CommonEntity_CommonEntityGroup FOREIGN KEY(CommonEntityGroupId) 
        REFERENCES CommonEntityGroup(Id)
);
GO

CREATE UNIQUE INDEX IX_CommonEntity_CommonEntityGroupId_Name 
    ON CommonEntity(CommonEntityGroupId, Name)
GO

例如，生产者 A 保存了一些CommonEntityMeeting s，而生产者 B 保存了CommonEntitySet s。 他们中的任何一个都必须保留与其特定项目相关的CommonEntity 。

基本上，关键点是：

• 有独立的生产者。
• 它们同时运行。
• 理论上（尽管这可能会改变并且现在还不完全正确）它们将通过相同的 Web 服务（ASP.Net Web API）运行，只是使用它们各自的端点/“资源”。 因此，理想的解决方案不应依赖于此。
• 他们努力保留可能包含尚不存在的 CommonEntity/CommonEntityGroup 对象的不同对象图。
• CommonEntity/CommonEntityGroup一经创建便不可变，此后永远不会被修改或删除。
• CommonEntity/CommonEntityGroup 根据它们的一些属性是唯一的（ Name和相关的公共实体，如果有的话（例如CommonEntity通过CommonEntity.Name + CommonEntityGroup.Name是唯一的））。
• 生产者不知道/关心那些CommonEntities ID - 他们通常只传递带有这些CommonEntities Names （唯一）和相关信息的 DTO。 因此，必须通过Name找到/创建任何Common(Group)Entity 。
• 生产者有一定的可能性会尝试同时创建相同的 CommonEntity/CommonEntityGroup。
• 尽管这样的 CommonEntity/CommonEntityGroup 对象更有可能已经存在于 db 中。

那么，使用实体框架（数据库优先，尽管它可能无关紧要）作为DAL和 SQL Server 作为存储，有什么有效和可靠的方法可以确保所有这些生产者同时成功地持久保存它们的相交对象图？

考虑到UNIQUE INDEX已经确保不会有重复的CommonEntities （Name、GroupName 对是唯一的），我可以看到以下解决方案：

1. 在构建对象图的其余部分之前，确保找到/创建了每个 CommonEntity/CommonGroupEntity+ SaveChanged() 。

在这种情况下，当为相关实体调用SaveChanges时，不会由于其他生产者之前创建相同的实体而导致任何索引违规。

为了实现它，我将有一些

public class CommonEntityGroupRepository // sort of
{
    public CommonEntityGroupRepository(EntitiesDbContext db) ...

    // CommonEntityRepository will use this class/method internally to create parent CommonEntityGroup.
    public CommonEntityGroup FindOrCreateAndSave(String groupName)
    {
        return
            this.TryFind(groupName) ?? // db.FirstOrDefault(...)
            this.CreateAndSave(groupName);
    }

    private CommonEntityGroup CreateAndSave(String groupName)
    {
        var group = this.Db.CommonEntityGroups.Create();
        group.Name = groupName;
        this.Db.CommonGroups.Add(group)

        try
        {
            this.Db.SaveChanges();
            return group;
        }
        catch (DbUpdateException dbExc)
        {
            // Check that it was Name Index violation (perhaps make indices IGNORE_DUP_KEY)
            return this.Find(groupName); // TryFind that throws exception.
        }
    }
}

使用这种方法将有多次调用 SaveChanges 并且每个 CommonEntity 将有自己的存储库，尽管它似乎是最可靠的解决方案。

2. 如果发生索引违规，只需创建整个图形并从头开始重建它

有点丑陋和低效（对于 10 个CommonEntities我们可能必须重试 10 次），但简单且或多或少可靠。

3. 如果发生索引违规，只需创建整个图形并替换重复条目

尽管可以实现特定于案例和更通用的基于反射的解决方案，但不确定是否有一种简单可靠的方法来替换或多或少复杂的对象图中的重复条目。

尽管如此，与以前的解决方案一样，它可能需要多次重试。

4. 尝试将此逻辑移至数据库 (SP)

怀疑在存储过程中处理会更容易。 这将与刚刚在数据库端实现的乐观或悲观方法相同。

尽管它可能会提供更好的性能（在这种情况下不是问题）并将插入逻辑放在一个共同的地方。

5. 在存储过程中使用 SERIALIZABLE 隔离级别/TABLOCKX+SERIALIZABLE 表提示- 它肯定可以工作，但我不希望比实际需要更多地锁定表，因为实际竞争非常罕见。 正如标题中已经提到的，我想找到一些乐观的并发方法。

---

我可能会尝试第一个解决方案，但也许有更好的选择或一些潜在的陷阱。

Answer 1

表值参数

一种选择是使用table valued parameters而不是单独调用数据库。

使用表值参数的示例过程：

create type dbo.CommonEntity_udt as table (
    CommonEntityGroupId int not null
  , Name      nvarchar(100) not null
  , primary key (CommonEntityGroupId,Name)
    );
go

create procedure dbo.CommonEntity_set (
    @CommonEntity dbo.CommonEntity_udt readonly
) as
begin;
  set nocount on;
  set xact_abort on;
  if exists (
    select 1 
      from @CommonEntity as s
        where not exists (
          select 1 
            from dbo.CommonEntity as t
            where s.Name = t.Name
              and s.CommonEntityGroupId = t.CommonEntityGroupId
            ))
    begin;
      insert dbo.CommonEntity (Name)
        select s.Name
          from @CommonEntity as s
          where not exists (
            select 1 
              from dbo.CommonEntity as t with (updlock, holdlock)
              where s.Name = t.Name
                and s.CommonEntityGroupId = t.CommonEntityGroupId
              );
    end;
end;
go

• 使用 Ostress.exe 测试插入的竞争条件 - Kendra Little

表值参数参考：

• SQL Server 2008 表值参数和 C# 自定义迭代器：天作之合！ - 伦纳德·洛贝尔
• 在实体框架中使用表值参数 - Ritesh Sharma
• 在 SQL Server 和 .NET 中使用表值参数 - Erland Sommarskog
• 如何在 Entity Framework 4.1 和 CodeFirst 中使用 TVP
• 使用表值参数最大化性能 - Dan Guzman

---

除非有令人信服的论据，否则我不建议merge 。 这种情况只看插入，所以看起来有点矫枉过正。

带有表值参数的示例merge版本：

create procedure dbo.CommonEntity_merge (
    @CommonEntity dbo.CommonEntity_udt readonly
) as
begin;
  set nocount on;
  set xact_abort on;
  if exists (
    select 1 
      from @CommonEntity as s
        where not exists (
          select 1 
            from dbo.CommonEntity as t
            where s.Name = t.Name
              and s.CommonEntityGroupId = t.CommonEntityGroupId
            ))
    begin;
      merge dbo.CommonEntity with (holdlock) as t
      using (select CommonEntityGroupId, Name from @CommonEntity) as s
      on (t.Name = s.Name
        and s.CommonEntityGroupId = t.CommonEntityGroupId)
      when not matched by target
        then insert (CommonEntityGroupId, Name) 
        values (s.CommonEntityGroupId, s.Name);
    end;
end;
go

merge参考：

• 谨慎使用 SQL Server 的MERGE语句 - Aaron Bertrand
• 阻塞合并语句的案例（LCK_M_RS_U 锁） - Kendra Little
• UPSERT 竞争条件与合并 - sqlteam
• 一个有趣的合并错误 - Paul White
• 我可以优化这个合并语句吗 - Aaron Bertrand
• 如果您正在使用索引视图和 MERGE，请阅读此内容！ - 亚伦伯特兰

---

ignore_dup_key代码注释：

// 检查是否违反名称索引（可能使索引 IGNORE_DUP_KEY）

ignore_dup_key将在幕后使用可serializable ； 非聚集索引的潜在开销； 并且即使索引是集群的， 根据重复的数量也会产生很大的成本。

这可以在存储过程中使用Sam Saffron 的 upsert（更新/插入）模式或此处显示的模式之一处理：不同错误处理技术的性能影响 - Aaron Bertrand 。

---

Answer 2

选择方法肯定取决于两个过程将使用的功能类型和数据量。

如果我们采用第一种方法，那么对于每个 SaveChanges() 调用，实体框架肯定会放置一个事务。 在大量记录的情况下，这可能会降低性能。

如果有大量记录需要插入/更新，那么我肯定会采用基于存储过程的方法。 使用这种方法，您将完全控制数据库并查询记录以检查它是否存在将非常容易（尽管此处可能需要进行一些微调）。 我不知道使用存储过程实现相同的功能是否会有任何挑战。 通过很少的实现优化，例如将数据加载到临时表（不是 SQL 临时表，而是可用于临时存储数据的物理表），这可以进一步增强以具有存储过程已处理的完整信息日志。

Answer 3

基于您的最后一个关键点，另一种解决方案是将您的“创建”逻辑移动到中央应用程序服务器/服务（请参阅更新 2） ，该服务器/服务具有用户可用于“添加”记录的队列。

由于您的大部分记录已经存在，如果您使用某种缓存，您应该能够使其非常有效

现在，关于一个记录的数字。
您必须记住，EF 并非旨在支持“批量”操作，因此，创建数千条记录会（真的）很慢。

我使用了 2 个可以帮助您的解决方案，并且非常快速地处理了大量记录 1) EntityFramework.BulkInsert
2) SqlBulkCopy

两者都非常易于使用

另外，我希望你已经看过在实体框架中插入的最快方法

更新
下面是我最近使用过两次的另一种解决方案
不要在用户执行“保存”时保存您的记录，而是将其安排在 X 秒后发生。
如果同时其他人试图保存相同的记录，只需“滑动”预定日期。

您可以在下面看到一个示例代码，该代码尝试将同一条记录保存 10 次（同时），但实际保存仅发生一次。

实际结果可以在这里看到：

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

namespace ConsoleApplicationScheduler
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcurrentSaveService service = new ConcurrentSaveService();
            int entity = 1;
            for (int i = 0; i < 10; i++)
            {
                //Save the same record 10 times(this could be conrurrent)
                service.BeginSave(entity);
            }

            Console.ReadLine();
        }
    }

    public class ConcurrentSaveService
    {
        private static readonly ConcurrentDictionary<int, DateTime> _trackedSubjectsDictionary = new ConcurrentDictionary<int, DateTime>();

        private readonly int _delayInSeconds;

        public ConcurrentSaveService()
        {
            _delayInSeconds = 5;
        }

        public async void BeginSave(int key)
        {
            Console.WriteLine("Started Saving");
            DateTime existingTaskDate;
            _trackedSubjectsDictionary.TryGetValue(key, out existingTaskDate);

            DateTime scheduledDate = DateTime.Now.AddSeconds(_delayInSeconds);
            _trackedSubjectsDictionary.AddOrUpdate(key, scheduledDate, (i, d) => scheduledDate);

            if (existingTaskDate > DateTime.Now)
                return;

            do
            {
                await Task.Delay(TimeSpan.FromSeconds(_delayInSeconds));

                DateTime loadedScheduledDate;
                _trackedSubjectsDictionary.TryGetValue(key, out loadedScheduledDate);
                if (loadedScheduledDate > DateTime.Now)
                    continue;

                if (loadedScheduledDate == DateTime.MinValue)
                    break;

                _trackedSubjectsDictionary.TryRemove(key, out loadedScheduledDate);

                if (loadedScheduledDate > DateTime.MinValue)
                {
                    //DoWork
                    Console.WriteLine("Update/Insert record:" + key);
                }

                break;
            } while (true);

            Console.WriteLine("Finished Saving");
        }
    }
}

更新 2由于您可以控制 WebAPI 应用程序中的“创建”过程，因此您应该能够使用某种缓存来避免重复，如以下伪代码

using System.Collections.Concurrent;
using System.Web.Http;

namespace WebApplication2.Controllers
{
    public class ValuesController : ApiController
    {
        static object _lock = new object();
        static ConcurrentDictionary<string, object> cache = new ConcurrentDictionary<string, object>();
        public object Post(InputModel value)
        {
            var existing = cache[value.Name];
            if (existing != null)
                return new object();//Your saved record

            lock (_lock)
            {
                existing = cache[value.Name];
                if (existing != null)
                    return new object();//Your saved record

                object newRecord = new object();//Save your Object

                cache.AddOrUpdate(value.Name, newRecord, (s, o) => newRecord);

                return newRecord;
            }
        }
    }

    public class InputModel
    {
        public string Name;
    }
}

Answer 4

生产者不知道/关心那些 CommonEntities 的 ID - 他们通常只传递带有这些 CommonEntities 的名称（唯一）和相关信息的 DTO。 因此，必须通过名称找到/创建任何公共（组）实体。

我假设存储对象的表通过它们的ID而不是Name引用CommonEntity 。

我假设对象的表定义如下所示：

CREATE TABLE SomeObject(
    Id INT NOT NULL IDENTITY(1, 1) PRIMARY KEY,
    ObjectName NVARCHAR(100) NOT NULL,
    CommonEntityId INT NOT NULL,
    CONSTRAINT FK_SomeObject_CommonEntity FOREIGN KEY(CommonEntityId) 
        REFERENCES CommonEntity(Id)
);

同时，高级SaveSomeObject函数将CommonEntity.Name和CommonEntityGroup.Name （不是ID ）作为参数。 这意味着函数必须在某处查找实体的Name并找到其对应的ID 。

因此，带有参数(ObjectName, CommonEntityName, CommonEntityGroupName)的高级SaveSomeObject函数可以通过两个步骤来实现：

CommonEntityID = GetCommonEntityID(CommonEntityName, CommonEntityGroupName);
SaveSomeObject(ObjectName, CommonEntityID);

GetCommonEntityID是一个辅助函数/存储过程，它通过Name查找实体的ID ，并在需要时创建一个实体（生成一个ID ）。

在这里，我们明确地将此步骤提取到一个单独的专用函数中。 只有这个函数必须处理并发问题。 它可以使用乐观并发方法或悲观方法来实现。 这个函数的用户并不关心它使用什么魔法来返回有效的ID ，但用户可以确定他可以安全地使用返回的ID来持久化对象的其余部分。

---

悲观并发方法

悲观并发方法很简单。 确保只能运行一个GetCommonEntityID实例。 我会使用sp_getapplock （而不是 SERIALIZABLE 事务隔离级别或表提示）。 sp_getapplock本质上是一个互斥锁，一旦获得锁，我们就可以确定此存储过程的其他实例不会并行运行。 这使逻辑变得简单 - 如果未找到，请尝试读取ID并INSERT新行。

CREATE PROCEDURE [dbo].[GetCommonEntityID]
    @ParamCommonEntityName NVARCHAR(100),
    @ParamCommonEntityGroupName NVARCHAR(100),
    @ParamCommonEntityID int OUTPUT
AS
BEGIN
    SET NOCOUNT ON;
    SET XACT_ABORT ON;

    BEGIN TRANSACTION;
    BEGIN TRY

        SET @ParamCommonEntityID = NULL;
        DECLARE @VarCommonEntityGroupID int = NULL;

        DECLARE @VarLockResult int;
        EXEC @VarLockResult = sp_getapplock
            @Resource = 'GetCommonEntityID_app_lock',
            @LockMode = 'Exclusive',
            @LockOwner = 'Transaction',
            @LockTimeout = 60000,
            @DbPrincipal = 'public';

        IF @VarLockResult >= 0
        BEGIN
            -- Acquired the lock

            SELECT @VarCommonEntityGroupID = ID
            FROM CommonEntityGroup
            WHERE Name = @ParamCommonEntityGroupName;

            IF @VarCommonEntityGroupID IS NULL
            BEGIN
                -- Such name doesn't exist, create it.
                INSERT INTO CommonEntityGroup (Name)
                VALUES (@ParamCommonEntityGroupName);

                SET @VarCommonEntityGroupID = SCOPE_IDENTITY();
            END;

            SELECT @ParamCommonEntityID = ID
            FROM CommonEntity
            WHERE
                Name = @ParamCommonEntityName
                AND CommonEntityGroupId = @VarCommonEntityGroupID
            ;

            IF @ParamCommonEntityID IS NULL
            BEGIN
                -- Such name doesn't exist, create it.
                INSERT INTO CommonEntity
                    (Name
                    ,CommonEntityGroupId)
                VALUES
                    (@ParamCommonEntityName
                    ,@VarCommonEntityGroupID);

                SET @ParamCommonEntityID = SCOPE_IDENTITY();
            END;

        END ELSE BEGIN
            -- TODO: process the error. Retry
        END;

        COMMIT TRANSACTION;
    END TRY
    BEGIN CATCH
        ROLLBACK TRANSACTION;
            -- TODO: process the error. Retry?
    END CATCH;

END

乐观并发方法

不要试图锁定任何东西。 乐观行事，查ID 。 如果未找到，请尝试INSERT新值并在存在唯一索引冲突时重试。

CREATE PROCEDURE [dbo].[GetCommonEntityID]
    @ParamCommonEntityName NVARCHAR(100),
    @ParamCommonEntityGroupName NVARCHAR(100),
    @ParamCommonEntityID int OUTPUT
AS
BEGIN
    SET NOCOUNT ON;
    SET XACT_ABORT ON;

    SET @ParamCommonEntityID = NULL;
    DECLARE @VarCommonEntityGroupID int = NULL;

    SELECT @VarCommonEntityGroupID = ID
    FROM CommonEntityGroup
    WHERE Name = @ParamCommonEntityGroupName;

    WHILE @VarCommonEntityGroupID IS NULL
    BEGIN
        -- Such name doesn't exist, create it.
        BEGIN TRANSACTION;
        BEGIN TRY

            INSERT INTO CommonEntityGroup (Name)
            VALUES (@ParamCommonEntityGroupName);

            SET @VarCommonEntityGroupID = SCOPE_IDENTITY();

            COMMIT TRANSACTION;
        END TRY
        BEGIN CATCH
            ROLLBACK TRANSACTION;
            -- TODO: Use ERROR_NUMBER() and ERROR_STATE() to check that
            -- error is indeed due to unique index violation and retry
        END CATCH;

        SELECT @VarCommonEntityGroupID = ID
        FROM CommonEntityGroup
        WHERE Name = @ParamCommonEntityGroupName;

    END;


    SELECT @ParamCommonEntityID = ID
    FROM CommonEntity
    WHERE
        Name = @ParamCommonEntityName
        AND CommonEntityGroupId = @VarCommonEntityGroupID
    ;

    WHILE @ParamCommonEntityID IS NULL
    BEGIN
        -- Such name doesn't exist, create it.
        BEGIN TRANSACTION;
        BEGIN TRY

            INSERT INTO CommonEntity
                (Name
                ,CommonEntityGroupId)
            VALUES
                (@ParamCommonEntityName
                ,@VarCommonEntityGroupID);

            SET @ParamCommonEntityID = SCOPE_IDENTITY();

            COMMIT TRANSACTION;
        END TRY
        BEGIN CATCH
            ROLLBACK TRANSACTION;
            -- TODO: Use ERROR_NUMBER() and ERROR_STATE() to check that
            -- error is indeed due to unique index violation and retry
        END CATCH;

        SELECT @ParamCommonEntityID = ID
        FROM CommonEntity
        WHERE
            Name = @ParamCommonEntityName
            AND CommonEntityGroupId = @VarCommonEntityGroupID
        ;

    END;

END

---

在这两种方法中，您都应该具有重试逻辑。 当您希望实体表中已有 Names 并且重试的可能性很低（如问题中描述的情况）时，乐观方法通常会更好。 当您希望有很多竞争进程尝试插入相同的名称时，悲观方法通常会更好。 如果您序列化插入，您的情况可能会更好。