高并发场景下的EF Core实战：从冲突检测到解决方案-优快云博客

高并发场景下的EF Core实战：从冲突检测到解决方案

【免费下载链接】efcore efcore: 是 .NET 平台上一个开源的对象关系映射（ORM）框架，用于操作关系型数据库。适合开发者使用 .NET 进行数据库操作，简化数据访问和持久化过程。项目地址: https://gitcode.com/GitHub_Trending/ef/efcore

你是否曾在电商秒杀活动中遭遇过库存超卖？或者在多用户编辑系统中丢失过重要数据？这些问题的根源往往是并发处理不当。本文将通过EF Core（Entity Framework Core，对象关系映射框架）的并发处理机制，带你掌握解决高并发场景的专业策略。读完你将学会：

如何使用EF Core的并发令牌机制检测冲突
三种经典的并发冲突解决方案
处理复杂关联实体冲突的进阶技巧
结合实际业务场景选择最优策略

并发冲突的本质与EF Core的应对机制

在多用户同时操作同一数据时，若无有效控制，会产生"丢失更新"问题。例如两个用户同时修改商品价格，后提交的更新会覆盖前者的更改。EF Core通过乐观并发控制（Optimistic Concurrency Control）解决此问题，核心原理是：不阻止并发操作，而是在保存时检测冲突。

EF Core的并发检测依赖于并发令牌（Concurrency Token）。当实体类中某个属性被标记为并发令牌后，EF Core会在UPDATE语句的WHERE子句中包含该字段，只有令牌值匹配时才允许更新。若检测到冲突，将抛出DbUpdateConcurrencyException异常。

并发令牌的实现方式

在EF Core中配置并发令牌有两种常用方式：

// 数据注解方式
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    
    [Timestamp] // 自动生成的字节数组令牌
    public byte[] RowVersion { get; set; }
}

// Fluent API方式（更灵活）
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>()
        .Property(p => p.Price)
        .IsConcurrencyToken(); // 将Price字段设为并发令牌
}

注意：[Timestamp]特性会自动生成数据库中的ROWVERSION类型字段，每次记录更新时自动递增，适合大多数场景。而IsConcurrencyToken()可将普通字段设为令牌，但需手动管理令牌值更新。

EF Core的并发检测逻辑在ConcurrencyDetector类中实现，通过EnterCriticalSection()方法确保在关键代码段中只有一个线程执行，避免竞态条件：

// 源码位置：src/EFCore/Infrastructure/Internal/ConcurrencyDetector.cs
public virtual ConcurrencyDetectorCriticalSectionDisposer EnterCriticalSection()
{
    if (Interlocked.Increment(ref _count) == 1)
    {
        _semaphoreSlim.Wait();
    }
    return new ConcurrencyDetectorCriticalSectionDisposer(this);
}

并发冲突的检测与捕获

当并发冲突发生时，EF Core会抛出DbUpdateConcurrencyException异常。我们需要在业务代码中捕获此异常并处理。以下是一个典型的并发冲突场景：

public async Task UpdateProductPrice(int productId, decimal newPrice)
{
    using var context = new AppDbContext();
    var product = await context.Products.FindAsync(productId);
    product.Price = newPrice;
    
    try
    {
        await context.SaveChangesAsync();
    }
    catch (DbUpdateConcurrencyException ex)
    {
        // 冲突处理逻辑将在下文详细介绍
        await HandleConcurrencyConflict(ex, context);
    }
}

EF Core的测试代码中提供了丰富的并发场景测试，例如OptimisticConcurrencyTestBase类中的ConcurrencyTestAsync方法，模拟了各种并发冲突场景：

// 源码位置：test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs
private async Task ConcurrencyTestAsync<TException>(
    Func<F1Context, Task> storeChange,
    Func<F1Context, Task> clientChange,
    Func<F1Context, TException, Task> resolver,
    Func<F1Context, Task> validator)
    where TException : Exception
{
    // 1. 创建事务和两个上下文模拟并发操作
    // 2. 执行存储端更改和客户端更改
    // 3. 捕获并处理并发异常
    // 4. 验证最终结果
}

三种经典并发冲突解决方案

面对并发冲突，EF Core提供了灵活的处理机制。根据业务场景不同，可选择以下三种解决方案：

1. 采用数据库最新值（覆盖客户端更改）

当业务允许覆盖客户端更改时，可直接采用数据库中的最新值。实现方式是获取数据库当前值并更新实体的原始值：

private async Task HandleConcurrencyConflict(
    DbUpdateConcurrencyException ex, AppDbContext context)
{
    var entry = ex.Entries.Single();
    var databaseValues = await entry.GetDatabaseValuesAsync();
    
    // 使用数据库值覆盖当前值和原始值
    entry.CurrentValues.SetValues(databaseValues);
    entry.OriginalValues.SetValues(databaseValues);
    
    // 保存更新后的值
    await context.SaveChangesAsync();
}

EF Core测试代码中的Simple_concurrency_exception_can_be_resolved_with_store_values方法展示了这种策略的实现：

// 源码位置：test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs
public virtual Task Simple_concurrency_exception_can_be_resolved_with_store_values()
    => ConcurrencyTestAsync(
        StorePodiums, async (_, ex) =>
        {
            var driverEntry = ex.Entries.Single();
            var storeValues = await driverEntry.GetDatabaseValuesAsync();
            driverEntry.CurrentValues.SetValues(storeValues);
            driverEntry.OriginalValues.SetValues(storeValues);
        });

2. 合并客户端与数据库更改

当需要保留客户端更改时，可合并数据库值与客户端更改。典型场景是：用户A修改商品价格，用户B修改商品描述，合并后两者的更改都应保留：

private async Task MergeConcurrencyConflict(
    DbUpdateConcurrencyException ex, AppDbContext context)
{
    var entry = ex.Entries.Single();
    var databaseValues = await entry.GetDatabaseValuesAsync();
    var clientValues = entry.CurrentValues;
    
    // 只合并非价格字段（假设价格字段已冲突）
    foreach (var property in entry.Metadata.GetProperties())
    {
        if (property.Name != "Price") // 排除冲突字段
        {
            clientValues[property] = databaseValues[property];
        }
    }
    
    // 更新原始值为数据库值
    entry.OriginalValues.SetValues(databaseValues);
    await context.SaveChangesAsync();
}

3. 提示用户手动解决冲突

在敏感业务场景（如金融交易）中，需由用户确认最终版本。此时应将冲突信息返回给前端，由用户选择保留哪个版本：

private async Task<UserResolution> GetUserResolution(
    DbUpdateConcurrencyException ex)
{
    var entry = ex.Entries.Single();
    var databaseValues = await entry.GetDatabaseValuesAsync();
    var clientValues = entry.CurrentValues;
    
    // 构建冲突数据返回给前端
    return new UserResolution
    {
        EntityType = entry.Metadata.ClrType.Name,
        DatabaseValues = databaseValues.ToObject(),
        ClientValues = clientValues.ToObject(),
        ConflictedProperties = entry.Metadata.GetProperties()
            .Where(p => !object.Equals(
                databaseValues[p], clientValues[p]))
            .Select(p => p.Name)
            .ToList()
    };
}

复杂关联实体的并发处理

在处理包含关联关系的实体时，并发冲突会变得更加复杂。例如订单和订单项组成的聚合根，当两者都可能被并发修改时，需要特殊处理。

处理一对一关联冲突

对于共享并发令牌的一对一关联实体，应先处理依赖实体冲突，再处理主体实体：

// 源码位置：test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs
public virtual Task Two_concurrency_issues_in_one_to_one_related_entities_can_be_handled_by_dealing_with_dependent_first()
    => ConcurrencyTestAsync(
        async c => 
        {
            // 修改Chassis（依赖实体）和Team（主体实体）
            var chassis = await c.Set<Chassis>().SingleAsync(c => c.Name == "MP4-25");
            var team = await c.Teams.SingleAsync(t => t.Id == Team.McLaren);
            chassis.Name = "MP4-25b";
            team.Principal = "Larry David";
        },
        async (c, ex) =>
        {
            // 先处理依赖实体冲突
            var entry = ex.Entries.Single();
            Assert.IsAssignableFrom<Chassis>(entry.Entity);
            await entry.ReloadAsync();
            
            // 再处理主体实体冲突
            try
            {
                await c.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException ex2)
            {
                var entry2 = ex2.Entries.Single();
                Assert.IsAssignableFrom<Team>(entry2.Entity);
                await entry2.ReloadAsync();
            }
        });

处理多对多关联冲突

多对多关系（如文章与标签）的并发冲突需特别注意连接表的处理。EF Core测试中模拟了添加重复关联的场景：

// 源码位置：test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs
public virtual Task Attempting_to_add_same_relationship_twice_for_many_to_many_results_in_independent_association_exception()
{
    return ConcurrencyTestAsync<DbUpdateException>(
        Change,
        Change,
        (c, ex) =>
        {
            var entry = ex.Entries.Single();
            Assert.IsAssignableFrom<TeamSponsor>(entry.Entity);
            return Task.CompletedTask;
        },
        null);

    async Task Change(F1Context c)
    {
        await c.Teams.Include(e => e.Sponsors).LoadAsync();
        (await c.Teams.SingleAsync(t => t.Id == Team.McLaren)).Sponsors.Add(
            await c.Sponsors.SingleAsync(s => s.Name.Contains("Shell")));
    }
}

性能优化与最佳实践

在高并发场景下，除了正确处理冲突，还需关注性能优化。以下是经过实践验证的最佳实践：

1. 选择合适的并发令牌类型

令牌类型	优点	缺点	适用场景
Timestamp/RowVersion	自动更新，低冲突	仅支持字节数组	大多数CRUD场景
版本号（int）	直观，支持整数比较	需手动更新	需向用户展示版本
业务字段（如价格）	天然包含业务意义	易冲突，不适合高频更新字段	简单业务场景

2. 减少长事务与锁竞争

EF Core测试代码中的Calling_Reload_on_owned_entity_works方法展示了如何通过短事务减少锁竞争：

// 源码位置：test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs
public virtual async Task Calling_Reload_on_owned_entity_works(bool async)
{
    using var c = CreateF1Context();
    await c.Database.CreateExecutionStrategy().ExecuteAsync(
        c, async context =>
        {
            using var transaction = BeginTransaction(context.Database);
            // 核心逻辑：查询->修改->保存，尽量缩短事务时间
            transaction.Commit();
        });
}

3. 批量操作的并发处理

对于批量更新，应使用EF Core 7.0+引入的ExecuteUpdateAsync方法，它直接生成SQL语句，避免加载实体到内存，大幅减少冲突概率：

// 高效批量更新，减少内存占用和冲突机会
await context.Products
    .Where(p => p.CategoryId == 1)
    .ExecuteUpdateAsync(s => s
        .SetProperty(p => p.Price, p => p.Price * 1.1m)
        .SetProperty(p => p.RowVersion, p => Guid.NewGuid()));

4. 结合分布式锁处理极端场景

当乐观并发控制仍无法满足需求（如秒杀系统），可结合分布式锁（如Redis锁）使用：

public async Task SeckillProduct(int productId, int userId)
{
    var lockKey = $"product_{productId}_lock";
    using var redisLock = await _redisClient.AcquireLockAsync(lockKey, TimeSpan.FromSeconds(10));
    
    if (redisLock == null)
    {
        throw new Exception("系统繁忙，请稍后再试");
    }
    
    using var context = new AppDbContext();
    var product = await context.Products.FindAsync(productId);
    
    if (product.Stock <= 0)
    {
        throw new Exception("商品已抢完");
    }
    
    product.Stock--;
    await context.SaveChangesAsync();
    
    // 创建订单等后续操作
}

总结与展望

EF Core提供了强大而灵活的并发处理机制，从基础的并发令牌到复杂的关联实体冲突处理，覆盖了大多数业务场景。选择策略时应遵循：

简单场景：使用Timestamp令牌+自动冲突处理
中等复杂度：合并字段+手动解决冲突
高并发场景：乐观并发+分布式锁组合方案

随着EF Core的不断发展，未来版本可能会引入更智能的冲突合并算法和更高效的批量操作支持。作为开发者，我们需要持续关注这些变化，并根据实际业务场景选择最优方案。

掌握EF Core并发处理，不仅能解决当前问题，更能帮助我们深入理解分布式系统的数据一致性挑战。建议结合EF Core官方文档和源代码（如test/EFCore.Specification.Tests/OptimisticConcurrencyTestBase.cs）进一步学习，构建更健壮的高并发系统。

点赞+收藏+关注，获取更多EF Core实战技巧！下期预告：《EF Core性能调优：从SQL生成到索引优化》。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考