如果试图在lock块中使用await关键字时使用lock关键字，会得到这个编译错误：cannot await in the body of a lock statement。原因是在await完成之后，该方法可能会在一个不同的线程中运行，而不是await关键字之前的线程(调用线程)。lock关键字需要同一个线程中获取锁和释放锁。

下面的代码块会导致编译错误：

        private static object s_syncLock = new object();static async Task IncorrectLockAsync() {lock (s_syncLock){Console.WriteLine($"{nameof(IncorrectLockAsync)} started");await Task.Delay(500); // compiler error: cannot await in the bodyConsole.WriteLine($"{nameof(IncorrectLockAsync)} ending");}            }

如何解决这个问题？不能为此使用Monitor，因为Monitor需要从它获取锁的同一线程中释放锁。lock关键字基于Monitor。

虽然Mutex对象可以用于不同进程之间的同步，但它有相同的问题：它为线程授予了一个锁。从不同的线程中释放锁不可能的。相反，可以使用Semaphore或SemaphoreSlim类。Semaphore可以从不同的线程中释放信号量。

下面的代码片段使用SemaphoreSlim对象上的WaitAsync等待获得一个信号量。SemaphoreSlim对象初始化为计数1，因此对信号量的等待只授予一次。在finally代码块中，通过调用Release方法释放信号量：

        private static SemaphoreSlim s_asyncLock = new SemaphoreSlim(1);static async Task LockWithSemaphore(string title) {Console.WriteLine($"{title} waiting for lock");await s_asyncLock.WaitAsync();try{Console.WriteLine($"{title} {nameof(LockWithSemaphore)} started");await Task.Delay(500); // compiler error: cannot await in the bodyConsole.WriteLine($"{title} {nameof(LockWithSemaphore)} ending");}finally{s_asyncLock.Release();}}

下面尝试在多个任务中同时调用此方法。该方法RunUseSemaphoreAsync启动6个任务，并发地调用LockWithSemaphore方法：

        static async Task RunUseSemaphoreAsync(){Console.WriteLine(nameof(RunUseSemaphoreAsync));string[] messages = { "one","two","three","four","five","six"};Task[] tasks = new Task[messages.Length];for (int i = 0; i < messages.Length; i++){string message = messages[i];tasks[i] = Task.Run(async ()=>await LockWithSemaphore(message));}await Task.WhenAll(tasks);}

运行该程序，可以看到多个任务同时启动，但是在信号量被锁定后，所有其他任务都需要等待信号量再次释放：

RunUseSemaphoreAsync
two waiting for lock
five waiting for lock
four waiting for lock
two LockWithSemaphore started
three waiting for lock
one waiting for lock
six waiting for lock
two LockWithSemaphore ending
five LockWithSemaphore started
five LockWithSemaphore ending
four LockWithSemaphore started
four LockWithSemaphore ending
three LockWithSemaphore started
three LockWithSemaphore ending
one LockWithSemaphore started
one LockWithSemaphore ending
six LockWithSemaphore started
six LockWithSemaphore ending

为了更容易地使用锁，可以创建一个实现IDisposable接口的类来管理资源。对于这个类，可以使用using语句，就像使用lock状态来锁定和释放信号量一样。

下面的代码片段(AsyncSemaphore)实现了该功能，该类在构造函数中分配一个SemaphoreSlim，在AsyncSemaphore上调用WaitAsync()方法时，返回实现接口IDisposable的内部类SemaphoreRelease。调用Dispose方法时，释放信号量：

    sealed class AsyncSemaphore{private class SemaphoreRelaese : IDisposable{private SemaphoreSlim _semaphore;public SemaphoreRelaese(SemaphoreSlim semaphore) => _semaphore = semaphore;public void Dispose(){_semaphore.Release();}}private SemaphoreSlim _semaphore;public AsyncSemaphore() => _semaphore = new SemaphoreSlim(1);public async Task<IDisposable> WaitAsync(){await _semaphore.WaitAsync();return new SemaphoreRelaese(_semaphore);}}

从前面所示的LockWithSemaphore方法中更改实现，现在可以使用using语句锁定信号量。记住，using语句创建一个try/finally块，在finally块中调用Dispose()方法：

        private static AsyncSemaphore s_asyncSemaphore = new AsyncSemaphore();static async Task UseAsyncSemaphore(string title) {using (await s_asyncSemaphore.WaitAsync()){Console.WriteLine($"{title} {nameof(LockWithSemaphore)} started");await Task.Delay(500); // compiler error: cannot await in the bodyConsole.WriteLine($"{title} {nameof(LockWithSemaphore)} ending");}}

使用类似于LockWithSemaphore方法的UseAsyncSemaphore方法会执行相同的行为。然而，类只编写一次。