EFCore 高并发

有常见的并发场景？如果我们使用EFCore常用的解决方法会出现哪些问题？对应不同的并发场景我们应该选择哪些的处理方式?

参照：事务的四种隔离级别详解_事务隔离级别-CSDN博客

Github:summerZoo123/EFConcurrentDemo (github.com)

数据库：

CREATE TABLE `phone` (

  `Id` int NOT NULL AUTO_INCREMENT COMMENT '主键',

  `Name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,

  `Price` decimal(10,2) NOT NULL,

  `PublishTime` datetime NOT NULL ON UPDATE CURRENT_TIMESTAMP,

  `Amount` int NOT NULL,

  `RowVer` char(36) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL COMMENT '版本号',

  PRIMARY KEY (`Id`)

) ENGINE=InnoDB AUTO_INCREMENT=34 DEFAULT CHARSET=utf8mb3;

-- ----------------------------

-- Records of phone

-- ----------------------------

INSERT INTO `phone` VALUES ('31', '华为Mate60', '6000.00', '2024-04-08 15:00:26', '10', '4abff008-122f-4f0d-9e3b-10863e7a2e3c');

INSERT INTO `phone` VALUES ('32', '小米14', '5000.00', '2024-04-10 10:59:41', '100', '0483330a-ab45-4d66-9e44-e60e072febe7');

INSERT INTO `phone` VALUES ('33', '一加12', '4000.00', '2024-04-08 15:00:26', '30', '1b004b2f-744e-4e55-bc7b-238c0e766e83');

什么是高并发

高并发意味着大流量，需要运用技术手段抵抗流量的冲击，这些手段好比操作流量，能让流量更平稳地被系统所处理，带给用户更好的体验。

常见的高并发场景

Web服务器处理请求 ：Web服务器需要同时处理多个来自不同用户的请求，这些请求可能包括静态资源请求、动态页面生成、数据库查询等。
多用户在线游戏 ：在线游戏需要同时处理多个玩家的操作，例如移动、攻击、聊天等，而这些操作都需要即时响应。
多线程文件处理 ：一个文件处理程序可以同时处理多个文件，每个文件可能在不同的线程中处理，以提高处理效率。
实时数据分析 ：在大数据环境下，需要对实时数据进行分析和处理，这就需要并发地处理多个数据流。
操作系统资源管理 ：操作系统需要同时管理多个应用程序和进程的资源请求，如CPU时间、内存、磁盘IO等。
电子商务网站订单处理 ：电子商务网站需要同时处理多个用户提交的订单，包括库存管理、支付处理、发货等操作。
多线程网络编程 ：网络服务器需要同时处理多个客户端的连接请求和数据交换，以提供并发的网络服务。
批处理任务 ：某些任务需要同时处理大量的数据，如数据清洗、转换、分析等，可以通过并行处理来提高效率。
实时通信应用 ：即时通讯应用程序需要支持多个用户之间的实时消息传递，这就需要并发处理消息发送和接收。
科学计算 ：在科学计算领域，需要对大规模数据进行并行处理，以加速计算过程，如天气预测、分子模拟等。

具体到数据库层面的场景，高并发意味着单位时间内要处理大量的数据的增、删、改等操作，保障正确的同时保证数据能正常可读。

EFCore处理高并发

现主要存在两种处理方式：悲观并发、乐观并发

概念介绍

悲观并发

悲观并发每次访问资源时都上锁，使得其它用户无法访问该资源。这种策略就是假设用户每次访问资源都认定会更新资源，所以每次访问资源就上锁，当资源被修改时，同一资源上的所有其它并发操作都将被暂停，直到当前操作完成，并且该资源上的锁被释放。

这种方法在资源争用较高的场景中是一个不错的选择。可以在锁定持续时间较短的场景中利用悲观并发。但是，当用户与数据交互时，悲观并发不能很好的扩展，会导致资源锁住很长的时间。再者当互联网连接较弱或断开连接时，将无法正确管理数据，这会影响数据库的工作。

乐观并发

乐观并发假设用户每次访问资源都不会更新资源，所以资源不会被锁定。但是在更新的时候会判断在此期间其它用户是否有更新操作。

乐观并发遵循“保存最新数据”的策略。

乐观并发通常用于数据稀缺的场景，也就是常说的频繁读取，这样可以提高吞吐量，但也会消耗额外的服务器资源。

乐观并发提高了性能也更好的支持扩展，因为它允许服务器在更短时间内为更多的客户端提供服务。

两种方式对比

悲观并发：比如有两个用户A,B，同时登录系统修改一个文档，如果A先进入修改，则系统会把该文档锁住，B就没办法打开了，只有等A修改完，完全退出的时候B才能进入修改。

乐观并发：A,B两个用户同时登录，如果A先进入修改紧跟着B也进入了。A修改文档的同时B也在修改，如果在A保存之后， B再保存他的修改，此时系统检测到数据库中文档记录与B刚进入时不一致，B保存时会抛出异常，修改失败。

具体解决方案

具体对应的操作：悲观并发—事务；乐观并发—乐观锁

EF Core支持监控乐观并发的两种方案：监测单个字段和监测整条数据，每种都对应DataAnnotations 和 FluentApi的两种配置方式，任选其一就行。

一种是将实体配置为并发令牌（监测单个字段）；另一种是在实体类中添加行版本属性(监测整行数据）。

并发令牌（需程序赋值）

Data Annotation 配置方式

 /// <summary>

    /// 手机库存

    /// </summary>

    public class PhoneStock

    {

        public int Id { get; set; }

        /// <summary>

        /// 名称

        /// </summary>

        public string Name { get; set; }

        /// <summary>

        /// 价格

        /// </summary>

        public Decimal Price { get; set; }

        /// <summary>

        /// 数量

        /// </summary>

        public int Amount { get; set; }

        /// <summary>

        /// 版本

        /// </summary>

        ///

        [ConcurrencyCheck]

        public Guid RowVer { get; set; }

    }

Fluent API 配置方式

protected override void OnModelCreating(ModelBuilder modelBuilder)

{

    modelBuilder.Entity<PhoneStock>()

        .Property(p => p.RowVer)

        .IsConcurrencyToken();

}

两种配置方式选择一种即可，使用并发令牌 EF Core 不会自动生成值，我们在更新实体记得给 RowVer属性赋值。

对应涉及高一致性字段对应的类，我们可以在对应的DBContext里重写SaveChange方法，在保存前给RowVer赋新值，这样不用写大量的并发令牌对应的赋值逻辑

public override int SaveChanges()

        {

            //给版本号赋值

            //检查数据库更改

            this.ChangeTracker.DetectChanges();

            //筛选新增/修改的实体对象

            var modifiedEntities = this.ChangeTracker

                .Entries()

                .Where(x => x.State == EntityState.Modified || x.State == EntityState.Added)

                .Select(x => x.Entity)

                .ToList();

            foreach (var entity in modifiedEntities)

            {

                //存储一个新的Guid值

                var property = entity?.GetType().GetProperty("RowVer");

                property?.SetValue(entity, Guid.NewGuid());

            }

            return base.SaveChanges();

        }

行版本属性-(数据库生成，仅限sqlserver)

Data Annotation 配置方式

public class Roles

{

    public int Id { get; set; }

    public string Name { get; set; }

    public string Description { get; set; }

    [Timestamp]

    public byte[] Timestamp { get; set; }

}

Fluent API 配置方式

protected override void OnModelCreating(ModelBuilder modelBuilder)

{

    modelBuilder.Entity<Roles>()

        .Property(p => p.Timestamp)

        .IsRowVersion();

}

也是两种选择一种，但与并发令牌不同的是不用给 Timestamp 赋值，EF Core 会自动产生一个值。

！！！注意，这种方式只在数据库sqlserver使用时有效，Timestamp能自动生成值，所以如果使用的是mysql还是选择第一种并发令牌的方式。

并发异常处理(mysql建议使用并发令牌)

参照：处理并发冲突 - EF Core | Microsoft Learn

配置完之后，实体执行更新或删除操作时，EF Core 都会将请求中的信息值与数据库表中的值进行比较。

如果两个值匹配，则执行操作。
如果值不匹配，则更新或删除操作将中止并且抛出一个 DbUpdateConcurrencyException。

当 EF Core 抛出 DbUpdateConcurrencyException ，我们可以做如下选择进行处理：

中止操作并要求用户刷新界面重新操作，称为使用他的，但会覆盖本地的操作数据。
使用当前值（最新一次提交的数据）并尝试重新 SaveChanges ，称为使用我的，但会覆盖服务器上的数据。
将冲突记录下来，让用户自己选择使用那个数据，称为手动解决。这种方式始终保持数据最新。

有三组值可用于帮助解决并发冲突：

“当前值”是应用程序尝试写入数据库的值。
“原始值”是在进行任何编辑之前最初从数据库中检索的值。
“数据库值”是当前存储在数据库中的值。

处理并发冲突的常规方法是：

在 SaveChanges 期间捕获 DbUpdateConcurrencyException。
使用 DbUpdateConcurrencyException.Entries 为受影响的实体准备一组新更改。
刷新并发令牌的原始值以反映数据库中的当前值。
重试该过程，直到不发生任何冲突

 /// <summary>

        /// 售出扣减库存

        /// </summary>

        /// <param name="id"></param>

        /// <param name="amount"></param>

        /// <returns></returns>

        public async Task<bool> PurchasePhone(int id, int amount)

        {

            var stock = await dbContext.Phones.SingleOrDefaultAsync(s => s.Id == id);

            int changeCount = 0;

            if (stock != null && stock.Amount >= amount)

            {

                stock.Amount -= amount;

                //dbContext.Update(stock);

                ///异常处理

                var saved = false;

                while (!saved)

                {

                    try

                    {

                        // Attempt to save changes to the database

                        //await Task.Delay(500);

                        changeCount =  dbContext.SaveChanges();

                        saved = true;

                    }

                    catch (DbUpdateConcurrencyException ex)

                    {

                        foreach (var entry in ex.Entries)

                        {

                            if (entry.Entity is PhoneStock)

                            {

                                //最开始从数据库读取到的值

                                var predbValues = entry.OriginalValues;

                                //准备写入的值（在最开始读到的数据库基础值上作业务运算后得到的值）

                                var proposedValues = entry.CurrentValues;

                                //数据库当前值

                                var databaseValues = entry.GetDatabaseValues();

                                var amountNow = 0;

                                foreach (var property in proposedValues.Properties)

                                {

                                    if (property.Name == nameof(PhoneStock.Amount) )

                                    {

                                        //读到的数据库原始值

                                        var predbVal = (int)predbValues[property];

                                        //期望值

                                        var proposedValue = (int)proposedValues[property];

                                        //数据库当前值

                                        var databaseValue = (int)databaseValues[property];

                                        //处理解释：假设初始库存是10，A买1台，B买2台。因为并发关系，读取到的初始值predbVal都是10，假设A先执行库存设置，则这时databaseValue就是10-1=9，而B执行到这里时proposedValue就是10-2 = 8,我们要做的就算计算要减的值是初始值（10）-期望值（8）=2;再用当前数据库的实际值databaseValue-2即可得到最终的值

                                        //换成B先执行库存设置，则这时databaseValue就是10-2=8，这里时proposedValue就是10-1 = 9,初始值（10）-期望值（9）=1，再用当前数据库的实际值databaseValue-1=7得到同样的结果

                                        int diff = predbVal - proposedValue;

                                        if (proposedValue >= 0)

                                        {

                                            var currentVal = databaseValue - diff;

                                            if (currentVal >= 0)

                                            {

                                                //给期望值重新赋值后，再用savechange保存

                                                proposedValues[property] = currentVal;

                                            }

                                            else

                                            {

                                                //直接报库存不足，或者直接返回false

                                                //throw new Exception("库存不足");

                                                return false;

                                            }

                                        }

                                        else

                                        {

                                            //直接报库存不足，或者直接返回false

                                            //throw new Exception("库存不足");

                                            return false;

                                        }

                                        break;

                                    }

                                    // TODO: decide which value should be written to database

                                    // proposedValues[property] = <value to be saved>;

                                }

                                // Refresh original values to bypass next concurrency check

                                entry.OriginalValues.SetValues(databaseValues);

                            }

                            else

                            {

                                throw new NotSupportedException(

                                    "Don't know how to handle concurrency conflicts for "

                                    + entry.Metadata.Name);

                            }

                        }

                    }

                }

            }

            return changeCount > 0;

        }