游戏客户端架构 / 系统课时
异步保存怎样避免状态竞争
异步保存怎样避免状态竞争
把保存放到后台只能解决“主线程被阻塞”的问题,却会带来新的并发风险:保存任务读取到一半时游戏状态可能已经变化,多次保存也可能乱序覆盖同一个文件。本节用“快照隔离 + 单写队列 + 文件访问门闩”建立可验证的异步保存边界。
学习目标
- 理解后台线程直接读取可变游戏状态为什么会产生不一致快照
- 用不可变快照和单写队列保证多次保存按顺序提交
- 让读档与写档共享同一文件访问边界,避免同时操作目标文件
先把运行时状态冻结成快照
最容易出错的做法,是后台任务直接持有 Player、Inventory、场景对象或可变集合的引用。后台正在序列化时,主线程可能同时增加金币、切换关卡或修改背包,最终写出的文件就可能混合两个时刻的数据。
因此保存请求的第一步应在安全线程上生成独立快照。快照中的字段要么是值类型和不可变对象,要么完成真正的深拷贝。只复制最外层对象而继续共享 List、Dictionary 等可变集合,仍然会发生竞争。

用单写队列消除乱序覆盖
如果每次点击保存都直接 Task.Run,两个任务完成顺序并不一定等于发起顺序。较早的任务如果最后才写完,就可能把较新的存档覆盖掉。稳妥做法是让保存请求进入 FIFO 队列,只保留一个实际写入者。
下面示例基于 .NET 6+ 的 System.Threading.Channels。PlayerState 只包含值类型字段,因此 with { } 足以形成独立快照;真实项目若包含集合或嵌套对象,需要改成深拷贝 DTO。
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);
}
}预期输出:
Loaded: hp=60, gold=25
Pending writes: 0两个保存请求虽然都异步执行,但真正写文件的只有一个消费者,因此较新的第二个快照一定在第一个之后提交。主线程后续修改 state 也不会改变已经排队的快照。
读档也要遵守同一并发边界
示例中的 _fileGate 同时保护写入和读取,避免读档恰好撞上文件正在被覆盖的瞬间。不过它只保证“同一时刻只有一个文件操作”,并不替你定义业务语义。
如果用户点下保存后马上读档,并且要求读到刚才那次保存的结果,就必须先等待对应的 RequestSaveAsync 返回,再调用 LoadAsync。如果允许读到“最近一次已经提交的版本”,则可以直接进入文件门闩等待当前操作结束。
失败处理与覆盖策略要提前定
队列解决的是顺序问题,不会自动解决断电、磁盘空间不足或进程在写入中途退出。生产实现通常还会先写临时文件,完成后再用平台允许的原子替换方式提交,从而避免留下半个文件。
同时要决定是否需要“合并保存”。例如自动保存每秒触发一次,但后台仍在写旧任务时,可以只保留最新快照,而不是无限堆积队列;而关键节点存档则可能要求每个请求都不能丢。无论采用哪种策略,都应以不可变快照为输入,并让最终文件提交只有一个明确的写入入口。
异步保存的核心不是线程越多越快,而是把并发控制收紧:主线程生成一致快照,队列决定顺序,单写者负责提交,读档共享文件门闩。只要这四个边界清晰,后台 IO 才不会用新的数据竞争换取表面的流畅度。