异步(async/await)上下文环境中锁的替代方案技术问询

兄弟，你遇到的这个问题太典型了——普通布尔值根本不是正经的同步原语，在简单的同步代码里可能靠“运气”没出问题，但一到async/await场景，因为await会释放当前线程去处理其他任务，原来的布尔锁逻辑直接就崩了，多个请求会同时钻进临界区，完全起不到互斥的作用。

别担心，针对async/await场景，有几个靠谱的锁替代方案，我给你详细说：

方案1：用SemaphoreSlim（原生最推荐） #

这是.NET官方提供的、专门支持异步等待的同步工具，完美适配async/await的非阻塞理念。你可以把它初始化为1，相当于一个互斥锁，同一时间只允许一个异步任务进入临界区。

直接上代码示例：

// 初始化一个只允许1个任务进入的信号量
private readonly SemaphoreSlim _asyncLock = new SemaphoreSlim(1, 1);

public async Task RunCriticalOperationAsync()
{
    // 异步等待获取锁，不会阻塞线程
    await _asyncLock.WaitAsync();
    try
    {
        // 这里放你的复杂异步操作，不管有多少await都安全
        await FetchDataFromApiAsync();
        await UpdateDatabaseAsync();
    }
    finally
    {
        // 一定要在finally里释放锁！防止异常导致锁一直被占用
        _asyncLock.Release();
    }
}

这里的关键是WaitAsync()会异步等待锁，不会像lock那样卡死线程；而finally块能保证不管临界区代码有没有抛出异常，锁都会被释放，避免死锁。

方案2：自定义AsyncLock（更简洁的封装） #

如果觉得每次写try/finally有点繁琐，你可以自己封装一个AsyncLock，利用C#的using语法糖自动释放锁，代码会更干净：

public class AsyncLock
{
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    private readonly Task<IDisposable> _releaseHandle;

    public AsyncLock()
    {
        // 预创建释放任务，减少重复分配
        _releaseHandle = Task.FromResult((IDisposable)new ReleaseHelper(_semaphore));
    }

    public Task<IDisposable> LockAsync()
    {
        var waitTask = _semaphore.WaitAsync();
        // 如果已经获取到锁，直接返回释放句柄；否则等待后返回
        return waitTask.IsCompleted
            ? _releaseHandle
            : waitTask.ContinueWith((_, state) => (IDisposable)new ReleaseHelper((SemaphoreSlim)state),
                _semaphore, CancellationToken.None,
                TaskContinuationOptions.ExecuteSynchronously,
                TaskScheduler.Default);
    }

    // 内部类负责释放锁
    private class ReleaseHelper : IDisposable
    {
        private readonly SemaphoreSlim _semaphore;
        private bool _disposed;

        public ReleaseHelper(SemaphoreSlim semaphore)
        {
            _semaphore = semaphore;
        }

        public void Dispose()
        {
            if (!_disposed)
            {
                _semaphore.Release();
                _disposed = true;
            }
        }
    }
}

使用的时候就非常简洁，using块结束自动释放锁：

private readonly AsyncLock _asyncLock = new AsyncLock();

public async Task RunCriticalOperationAsync()
{
    using (await _asyncLock.LockAsync())
    {
        // 临界区的异步代码，不用手动管释放
        await FetchDataFromApiAsync();
        await UpdateDatabaseAsync();
    }
}

这种封装能减少手动写finally的出错概率，代码可读性也更高。

为啥不能用普通lock？ #

顺便给你再明确一下：lock关键字是基于Monitor实现的，它是线程绑定的——当你在lock块里await的时候，当前线程会被释放，等await完成后，可能是另一个线程继续执行，这时候Monitor会因为线程不匹配直接抛出异常，而且根本起不到同步作用，所以绝对不能在async/await代码里用lock。

最后提醒一句：不管用哪种方案，一定要确保锁被正确释放，尤其是在有异常的情况下，否则会导致死锁，后续所有请求都拿不到锁，直接卡住。

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