异步函数中支持重入的Mutex替代方案咨询

在异步任务/异步函数场景中，传统的lock语句或Mutex并不适用——它们会阻塞线程，违背异步编程的非阻塞设计原则，而且无法感知任务上下文（只能识别线程）。要满足你提出的三个需求，最佳方案是实现任务感知的可重入异步锁，核心思路是用SemaphoreSlim保证排他性，结合AsyncLocal跟踪同一任务的重入次数。

方案核心逻辑 #

• 用SemaphoreSlim(1, 1)确保同一时间仅允许一个任务进入临界区（当任务未持有锁时）
• 用AsyncLocal<int>绑定到任务执行上下文，记录当前任务的重入次数：
  • 首次进入时，等待获取信号量，然后递增计数
  • 同一任务再次进入时，直接递增计数，无需等待信号量
  • 退出临界区时递减计数，当计数归0时释放信号量

完整实现代码 #

public class AsyncReentrantLock
{
    // 信号量：保证排他性，初始计数1，最大计数1
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    // 跟踪当前任务的重入次数，绑定任务上下文而非线程
    private readonly AsyncLocal<int> _reentrancyCount = new AsyncLocal<int>();

    // 获取异步锁，返回可自动释放的IDisposable对象
    public async Task<IDisposable> LockAsync(CancellationToken cancellationToken = default)
    {
        // 只有当当前任务未持有锁时，才等待信号量
        if (_reentrancyCount.Value == 0)
        {
            await _semaphore.WaitAsync(cancellationToken);
        }
        // 重入次数+1
        _reentrancyCount.Value++;
        // 返回释放器，using块结束时自动释放锁
        return new Releaser(this);
    }

    // 内部释放锁的逻辑
    private void Release()
    {
        _reentrancyCount.Value--;
        // 只有当重入次数归0时，才释放信号量
        if (_reentrancyCount.Value == 0)
        {
            _semaphore.Release();
        }
    }

    // 嵌套类：实现IDisposable，用于自动释放锁
    private class Releaser : IDisposable
    {
        private readonly AsyncReentrantLock _lock;
        private bool _disposed;

        public Releaser(AsyncReentrantLock @lock) => _lock = @lock;

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

使用示例 #

// 声明全局/类级别的异步锁实例
private readonly AsyncReentrantLock _asyncLock = new AsyncReentrantLock();

// 递归异步方法，演示可重入特性
public async Task RecursiveAsyncOperation(int depth)
{
    // 使用using块自动管理锁的释放
    using (await _asyncLock.LockAsync())
    {
        Console.WriteLine($"进入临界区，当前递归深度：{depth}");
        
        // 递归调用，同一任务可直接进入临界区
        if (depth > 0)
        {
            await RecursiveAsyncOperation(depth - 1);
        }
        
        Console.WriteLine($"退出临界区，当前递归深度：{depth}");
    }
}

方案满足需求的验证 #

1. 排他性：SemaphoreSlim(1)确保只有第一个任务能获取信号量，后续任务会等待直到信号量被释放
2. 可重入性：AsyncLocal跟踪同一任务的重入次数，同一任务再次调用LockAsync时无需等待，直接进入临界区
3. 任务感知：AsyncLocal绑定的是任务的执行上下文，而非线程，即使任务在不同线程上调度，也能正确识别同一个任务，避免跨任务的重入冲突

注意事项 #

• 必须使用await调用LockAsync，禁止同步等待（如.Wait()），否则会导致死锁
• 支持CancellationToken参数，可在等待锁的过程中响应取消请求
• 该实现为非公平锁，若需要公平性（按请求顺序获取锁），可额外维护等待队列，但大多数异步场景下非公平锁的性能更优

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