如何将C#旧代码中的lock同步锁重构为适配async/await的异步实现？

首先需要明确：C#原生lock关键字基于Monitor实现，要求锁的进入和释放必须在同一个线程执行，而await之后会切换线程上下文，因此无法直接在lock代码块内使用await，强行使用会直接编译报错，甚至引发死锁。
以下是可落地的改造方案： #

1. 首选方案：使用SemaphoreSlim实现异步排他锁 #

SemaphoreSlim从.NET Framework 4.0开始支持，.NET Core全版本兼容，自带异步等待方法WaitAsync()，可以完美替代lock实现异步场景下的排他锁，同时还能兼容原有同步调用逻辑。

改造步骤 #

1. 替换锁对象定义

// 替换原来的 object _lock = new object();
private readonly SemaphoreSlim _asyncLock = new SemaphoreSlim(1, 1);
// 初始计数1、最大计数1，等价于lock的排他锁效果

2. 实现异步锁逻辑

async Task AsyncGetOrder()
{
    // ... 其他前置逻辑
    await _asyncLock.WaitAsync();
    try
    {
        // 原lock块内的业务逻辑，可正常使用await调用异步方法
        await DoSomethingAsync();
    }
    finally
    {
        // 必须在finally内释放锁，避免异常导致锁泄漏
        _asyncLock.Release();
    }
}

3. 兼容原有同步方法（可选）
   如果需要保留旧的同步GetOrder方法，建议统一使用同一个SemaphoreSlim对象，避免新旧方法锁不互斥的问题：

void GetOrder()
{
    // ... 其他前置逻辑
    _asyncLock.Wait();
    try
    {
        // 原lock块内的业务逻辑
        DoSomething();
    }
    finally
    {
        _asyncLock.Release();
    }
}

注意：SemaphoreSlim默认不支持可重入，如果原有lock逻辑存在同一线程多次进入锁的重入场景，需要额外实现重入计数逻辑，或选择支持可重入的异步锁方案。

2. 封装工具类简化调用 #

如果项目中存在大量锁改造需求，可以封装通用的异步锁工具类，省去重复写try-finally的代码，实现你期望的简洁调用形式：

// 封装锁释放结构
public readonly struct AsyncLockReleaser : IDisposable
{
    private readonly SemaphoreSlim _lock;
    public AsyncLockReleaser(SemaphoreSlim @lock) => _lock = @lock;
    public void Dispose() => _lock?.Release();
}

// 扩展方法简化调用
public static async Task<AsyncLockReleaser> LockAsync(this SemaphoreSlim @lock)
{
    await @lock.WaitAsync();
    return new AsyncLockReleaser(@lock);
}

封装后的异步方法可以直接写成：

async Task AsyncGetOrder()
{
    // ... 其他前置逻辑
    using var _ = await _asyncLock.LockAsync();
    // 原lock块内的业务逻辑直接写在这里，using结束自动释放锁
    await DoSomethingAsync();
}

3. 特殊场景替代方案 #

• 如果原有逻辑依赖锁的可重入特性，可以直接使用成熟的第三方异步锁实现，比如Nito.AsyncEx库中的AsyncLock，原生支持可重入，API更加友好。
• 高并发低延迟的核心业务场景，可以考虑实现异步自旋锁，但实现复杂度较高，普通业务场景不推荐。

4. 改造注意事项 #

• 锁的释放必须放在finally块或using结构中，避免业务抛出异常导致锁永远无法释放，引发全局死锁。
• 异步锁的粒度要和原有lock粒度保持完全一致，不要随意扩大或缩小锁的范围，避免出现线程安全问题。
• 如果需要同时兼容新旧方法，必须使用同一个锁对象，不能同步方法用原生lock、异步方法用SemaphoreSlim，会导致锁失效，临界区不互斥。
• 多个锁嵌套的场景要严格保持锁的获取顺序和原有逻辑一致，避免异步场景下的锁顺序死锁。

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