如何不等待耗时任务完成异步更新内存聚合数据？

核心思路 #

要实现「添加记录后异步更新内存聚合列表且不阻塞请求」，需要解决两个关键问题：异步任务无阻塞启动和内存列表的线程安全读写。

步骤1：修正主方法，无阻塞启动长任务 #

先确保数据库写入操作完全完成，再异步启动排名更新任务，同时必须处理任务异常（避免静默失败难以排查）：

public async Task AddResults(List<Team> teams) {
    // 先完成数据库持久化，确保后续更新任务能读到新数据
    await context.AddRangeAsync(teams);
    await context.SaveChangesAsync();

    // 异步启动排名更新，不阻塞当前请求
    _ = Task.Run(async () => {
        try {
            await inMemoryService.SetRanking();
        }
        catch (Exception ex) {
            // 务必记录异常，比如通过日志组件写入错误日志
            // _logger.LogError(ex, "更新内存排名任务执行失败");
        }
    }).ConfigureAwait(false);
}

步骤2：保证内存列表的线程安全 #

之前出现「读取旧值」的问题，本质是多线程下读写普通集合导致的并发冲突。需要用线程安全的容器或锁机制保护内存聚合列表：

方案A：用ReaderWriterLockSlim保护单一全局排名

适合内存中存储单一全量排名列表的场景：

public class InMemoryService {
    private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
    private List<TeamRanking> _rankingList = new List<TeamRanking>();

    public async Task SetRanking() {
        // 从数据库拉取最新全量团队数据
        var allTeams = await _context.Teams.ToListAsync();
        // 计算新排名（替换为你的业务逻辑）
        var newRanking = allTeams.OrderByDescending(t => t.Points)
                                 .Select(t => new TeamRanking { 
                                     TeamId = t.Id, 
                                     TeamName = t.Name, 
                                     Points = t.Points 
                                 }).ToList();

        // 写入时加写锁，避免与读操作冲突
        _lock.EnterWriteLock();
        try {
            _rankingList = newRanking;
        }
        finally {
            _lock.ExitWriteLock();
        }
    }

    // 对外提供的读取方法，加读锁保证数据一致性
    public List<TeamRanking> GetCurrentRanking() {
        _lock.EnterReadLock();
        try {
            // 返回副本，避免外部代码修改内部集合
            return new List<TeamRanking>(_rankingList);
        }
        finally {
            _lock.ExitReadLock();
        }
    }
}

方案B：用ConcurrentDictionary处理分组排名

如果是按CompetitionId分组存储排名，用ConcurrentDictionary更高效：

public class InMemoryService {
    private readonly ConcurrentDictionary<int, List<TeamRanking>> _competitionRankings = new ConcurrentDictionary<int, List<TeamRanking>>();

    public async Task SetRanking() {
        var allTeams = await _context.Teams.ToListAsync();
        // 按赛事分组计算排名
        var groupedRankings = allTeams.GroupBy(t => t.CompetitionId)
                                     .ToDictionary(g => g.Key, g => 
                                         g.OrderByDescending(t => t.Points)
                                          .Select(t => new TeamRanking { 
                                              TeamId = t.Id, 
                                              TeamName = t.Name, 
                                              Points = t.Points 
                                          }).ToList());

        // 批量更新线程安全字典
        foreach (var kvp in groupedRankings) {
            _competitionRankings.AddOrUpdate(kvp.Key, kvp.Value, (key, oldList) => kvp.Value);
        }
    }

    public List<TeamRanking> GetRankingForCompetition(int competitionId) {
        _competitionRankings.TryGetValue(competitionId, out var ranking);
        // 返回副本避免外部修改内部集合
        return ranking?.ToList() ?? new List<TeamRanking>();
    }
}

为什么之前的方法无效？ #

1. 直接丢弃任务（_ = inMemoryService.SetRanking();）：

   • 未处理多线程读写冲突，读取时可能获取到未更新完成的半状态数据；
   • 未捕获任务异常，一旦SetRanking出错，会出现静默失败甚至程序崩溃（.NET早期版本会终止进程）。

2. 用ConfigureAwait(false)等待：

   • ConfigureAwait(false)只是取消上下文捕获，但本质还是会等待任务执行完毕，所以请求依然会被阻塞。

内容的提问来源于stack exchange，提问作者AlleXyS