游戏客户端架构 / 系统课时

异步保存怎样避免状态竞争

异步保存怎样避免状态竞争

把保存放到后台只能解决“主线程被阻塞”的问题,却会带来新的并发风险:保存任务读取到一半时游戏状态可能已经变化,多次保存也可能乱序覆盖同一个文件。本节用“快照隔离 + 单写队列 + 文件访问门闩”建立可验证的异步保存边界。

学习目标

  • 理解后台线程直接读取可变游戏状态为什么会产生不一致快照
  • 用不可变快照和单写队列保证多次保存按顺序提交
  • 让读档与写档共享同一文件访问边界,避免同时操作目标文件

先把运行时状态冻结成快照

最容易出错的做法,是后台任务直接持有 Player、Inventory、场景对象或可变集合的引用。后台正在序列化时,主线程可能同时增加金币、切换关卡或修改背包,最终写出的文件就可能混合两个时刻的数据。

因此保存请求的第一步应在安全线程上生成独立快照。快照中的字段要么是值类型和不可变对象,要么完成真正的深拷贝。只复制最外层对象而继续共享 List、Dictionary 等可变集合,仍然会发生竞争。

异步保存的快照、队列与文件访问关系

用单写队列消除乱序覆盖

如果每次点击保存都直接 Task.Run,两个任务完成顺序并不一定等于发起顺序。较早的任务如果最后才写完,就可能把较新的存档覆盖掉。稳妥做法是让保存请求进入 FIFO 队列,只保留一个实际写入者。

下面示例基于 .NET 6+ 的 System.Threading.Channels。PlayerState 只包含值类型字段,因此 with { } 足以形成独立快照;真实项目若包含集合或嵌套对象,需要改成深拷贝 DTO。

csharp
using System;
using System.IO;
using System.Text.Json;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;

record PlayerState(int Hp, int Gold);
record SaveRequest(PlayerState Snapshot, TaskCompletionSource<bool> Completion);

sealed class SaveCoordinator : IAsyncDisposable
{
    private readonly string _path;
    private readonly Channel<SaveRequest> _queue = Channel.CreateUnbounded<SaveRequest>();
    private readonly SemaphoreSlim _fileGate = new(1, 1);
    private readonly Task _worker;
    private int _pendingWrites;

    public int PendingWrites => Volatile.Read(ref _pendingWrites);

    public SaveCoordinator(string path)
    {
        _path = path;
        _worker = ProcessQueueAsync();
    }

    public Task RequestSaveAsync(PlayerState state)
    {
        var snapshot = state with { };
        var completion = new TaskCompletionSource<bool>(
            TaskCreationOptions.RunContinuationsAsynchronously);

        Interlocked.Increment(ref _pendingWrites);

        if (!_queue.Writer.TryWrite(new SaveRequest(snapshot, completion)))
        {
            Interlocked.Decrement(ref _pendingWrites);
            throw new InvalidOperationException("Save queue is closed.");
        }

        return completion.Task;
    }

    private async Task ProcessQueueAsync()
    {
        await foreach (var request in _queue.Reader.ReadAllAsync())
        {
            try
            {
                string json = JsonSerializer.Serialize(request.Snapshot);

                await _fileGate.WaitAsync();
                try
                {
                    await File.WriteAllTextAsync(_path, json);
                }
                finally
                {
                    _fileGate.Release();
                }

                request.Completion.SetResult(true);
            }
            catch (Exception ex)
            {
                request.Completion.SetException(ex);
            }
            finally
            {
                Interlocked.Decrement(ref _pendingWrites);
            }
        }
    }

    public async Task<PlayerState?> LoadAsync()
    {
        await _fileGate.WaitAsync();
        try
        {
            if (!File.Exists(_path))
                return null;

            string json = await File.ReadAllTextAsync(_path);
            return JsonSerializer.Deserialize<PlayerState>(json);
        }
        finally
        {
            _fileGate.Release();
        }
    }

    public async ValueTask DisposeAsync()
    {
        _queue.Writer.Complete();
        await _worker;
        _fileGate.Dispose();
    }
}

class Program
{
    static async Task Main()
    {
        string path = Path.Combine(Path.GetTempPath(), "save-demo.json");

        await using var saves = new SaveCoordinator(path);

        var state = new PlayerState(100, 10);
        Task firstSave = saves.RequestSaveAsync(state);

        state = state with { Hp = 60, Gold = 25 };
        Task secondSave = saves.RequestSaveAsync(state);

        await Task.WhenAll(firstSave, secondSave);

        PlayerState? loaded = await saves.LoadAsync();
        Console.WriteLine($"Loaded: hp={loaded!.Hp}, gold={loaded.Gold}");
        Console.WriteLine($"Pending writes: {saves.PendingWrites}");

        File.Delete(path);
    }
}

预期输出:

text
Loaded: hp=60, gold=25
Pending writes: 0

两个保存请求虽然都异步执行,但真正写文件的只有一个消费者,因此较新的第二个快照一定在第一个之后提交。主线程后续修改 state 也不会改变已经排队的快照。

读档也要遵守同一并发边界

示例中的 _fileGate 同时保护写入和读取,避免读档恰好撞上文件正在被覆盖的瞬间。不过它只保证“同一时刻只有一个文件操作”,并不替你定义业务语义。

如果用户点下保存后马上读档,并且要求读到刚才那次保存的结果,就必须先等待对应的 RequestSaveAsync 返回,再调用 LoadAsync。如果允许读到“最近一次已经提交的版本”,则可以直接进入文件门闩等待当前操作结束。

失败处理与覆盖策略要提前定

队列解决的是顺序问题,不会自动解决断电、磁盘空间不足或进程在写入中途退出。生产实现通常还会先写临时文件,完成后再用平台允许的原子替换方式提交,从而避免留下半个文件。

同时要决定是否需要“合并保存”。例如自动保存每秒触发一次,但后台仍在写旧任务时,可以只保留最新快照,而不是无限堆积队列;而关键节点存档则可能要求每个请求都不能丢。无论采用哪种策略,都应以不可变快照为输入,并让最终文件提交只有一个明确的写入入口。

异步保存的核心不是线程越多越快,而是把并发控制收紧:主线程生成一致快照,队列决定顺序,单写者负责提交,读档共享文件门闩。只要这四个边界清晰,后台 IO 才不会用新的数据竞争换取表面的流畅度。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

异步保存怎样避免状态竞争

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通