为什么我不能使用“await”锁定语句体内的运算符？

Question

lock 语句中不允许使用 C# (.NET Async CTP) 中的 await 关键字。

来自 MSDN：

安 wait 表达式不能在同步函数、查询中使用 表达式，在异常处理的 catch 或 finally 块中 语句，在锁定语句的块中，或在不安全的上下文中。

我认为由于某种原因，编译器团队很难或不可能实现这一点。

我尝试使用 using 语句解决问题：

class Async
{
    public static async Task<IDisposable> Lock(object obj)
    {
        while (!Monitor.TryEnter(obj))
            await TaskEx.Yield();

        return new ExitDisposable(obj);
    }

    private class ExitDisposable : IDisposable
    {
        private readonly object obj;
        public ExitDisposable(object obj) { this.obj = obj; }
        public void Dispose() { Monitor.Exit(this.obj); }
    }
}

// example usage
using (await Async.Lock(padlock))
{
    await SomethingAsync();
}

但这并没有按预期工作。在 ExitDisposable.Dispose 中对 Monitor.Exit 的调用似乎无限期地阻塞（大多数时候），导致当其他线程尝试获取锁时出现死锁。我怀疑我的工作不可靠，并且 lock 语句中不允许 await 语句的原因在某种程度上是相关的。

有谁知道为什么 await 不允许在 lock 语句体内使用？

Answer 1

我认为由于某种原因，编译器团队很难或不可能实现这一点。

不，实施起来一点也不困难或不可能——您自己实施的事实就证明了这一事实。相反，这是一个非常糟糕的主意，因此我们不允许这样做，以防止您犯此错误。

在 ExitDisposable.Dispose 中调用 Monitor.Exit 似乎会无限期地阻塞（大多数情况下），当其他线程尝试获取锁时会导致死锁。我怀疑我的工作的不可靠性和lock语句中不允许await语句的原因在某种程度上是相关的。

是的，您已经发现为什么我们将其定为非法。 在锁内等待是产生死锁的一个因素。

我相信您可以明白原因：在等待将控制权返回给调用者和方法恢复之间运行任意代码 >。该任意代码可能会取出产生锁顺序反转的锁，从而导致死锁。

更糟糕的是，代码可能会在另一个线程上恢复（在高级场景中；通常您会在执行等待的线程上再次拿起，但不一定），在这种情况下，解锁将解锁某个线程上的锁与取出锁的线程不同的线程。这是个好主意吗？不

。我注意到，出于同样的原因，在 lock 内执行 yield return 也是“最糟糕的做法”。这样做是合法的，但我希望我们将其定为非法。我们不会在“await”上犯同样的错误。

Answer 2

使用 SemaphoreSlim.WaitAsync< /a> 方法。

 await mySemaphoreSlim.WaitAsync();
 try {
     await Stuff();
 } finally {
     mySemaphoreSlim.Release();
 }

Answer 3

这只是 此答案，作者：1639030。

---

基本版本

---

using System;
using System.Threading;
using System.Threading.Tasks;

public class SemaphoreLocker
{
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

    public async Task LockAsync(Func<Task> worker)
    {
        await _semaphore.WaitAsync();
        try
        {
            await worker();
        }
        finally
        {
            _semaphore.Release();
        }
    }

    // overloading variant for non-void methods with return type (generic T)
    public async Task<T> LockAsync<T>(Func<Task<T>> worker)
    {
        await _semaphore.WaitAsync();
        try
        {
            return await worker();
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

用法：

public class Test
{
    private static readonly SemaphoreLocker _locker = new SemaphoreLocker();

    public async Task DoTest()
    {
        await _locker.LockAsync(async () =>
        {
            // [async] calls can be used within this block 
            // to handle a resource by one thread. 
        });
        // OR
        var result = await _locker.LockAsync(async () =>
        {
            // [async] calls can be used within this block 
            // to handle a resource by one thread. 
        });
    }
}

---

扩展版本

---

声称完全死锁安全的 LockAsync 方法版本（来自Jez 建议的第四次修订）。

using System;
using System.Threading;
using System.Threading.Tasks;

public class SemaphoreLocker
{
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

    public async Task LockAsync(Func<Task> worker)
    {
        var isTaken = false;
        try
        {
            do
            {
                try
                {
                }
                finally
                {
                    isTaken = await _semaphore.WaitAsync(TimeSpan.FromSeconds(1));
                }
            }
            while (!isTaken);
            await worker();
        }
        finally
        {
            if (isTaken)
            {
                _semaphore.Release();
            }
        }
    }

    // overloading variant for non-void methods with return type (generic T)
    public async Task<T> LockAsync<T>(Func<Task<T>> worker)
    {
        var isTaken = false;
        try
        {
            do
            {
                try
                {
                }
                finally
                {
                    isTaken = await _semaphore.WaitAsync(TimeSpan.FromSeconds(1));
                }
            }
            while (!isTaken);
            return await worker();
        }
        finally
        {
            if (isTaken)
            {
                _semaphore.Release();
            }
        }
    }
}

用法：

public class Test
{
    private static readonly SemaphoreLocker _locker = new SemaphoreLocker();

    public async Task DoTest()
    {
        await _locker.LockAsync(async () =>
        {
            // [async] calls can be used within this block 
            // to handle a resource by one thread. 
        });
        // OR
        var result = await _locker.LockAsync(async () =>
        {
            // [async] calls can be used within this block 
            // to handle a resource by one thread. 
        });
    }
}

Answer 4

基本上这是错误的做法。

有两种方法可以实现此目的：

• 保持锁定，仅在块末尾释放它。
  这是一个非常糟糕的主意，因为您不知道异步操作将花费多长时间。您应该只持有锁最短时间。这也可能是不可能的，因为线程拥有锁，而不是方法 - 并且您甚至可能无法在同一线程上执行异步方法的其余部分（取决于任务调度程序）。

• 释放await中的锁，并在await返回时重新获取锁
  这违反了 IMO 的最小惊讶原则，其中异步方法的行为应尽可能类似于等效的同步代码 - 除非您在锁块中使用 Monitor.Wait ，否则您希望拥有锁块的持续时间。

因此，基本上这里有两个相互竞争的要求 - 您不应该尝试在这里执行第一个要求，如果您想采用第二种方法，您可以通过使用两个单独的锁块来使代码更加清晰由await表达式分隔：

// Now it's clear where the locks will be acquired and released
lock (foo)
{
}
var result = await something;
lock (foo)
{
}

因此，通过禁止您在锁块本身中等待，该语言迫使您思考您真正想要做什么，并在您希望的代码中使该选择更加清晰写。

Answer 5

这是指构建异步协调基元，第 6 部分： AsyncLock , http://winrtstoragehelper.codeplex.com/ 、Windows 8 应用商店和 .net 4.5

以下是我对此的看法：

async/await 语言功能使许多事情变得相当简单，但它也引入了一个场景那是
以前很少遇到这么容易使用异步调用：重入。

对于事件处理程序来说尤其如此，因为对于许多事件，您对从事件处理程序返回后发生的情况没有任何线索。
实际可能发生的一件事是，您在第一个事件处理程序中等待的异步方法会从仍在该事件处理程序上的另一个事件处理程序中调用。
同一个线程。

这是我在 Windows 8 应用商店应用程序中遇到的一个真实场景：
我的应用程序有两个框架：进入和离开一个框架，我想将一些数据加载/安全到文件/存储。
OnNavigedTo/From 事件用于保存和加载。保存和加载是通过一些异步实用函数完成的（例如 http://winrtstoragehelper.codeplex.com/ ）。
当从帧 1 导航到帧 2 或沿其他方向导航时，将调用并等待异步加载和安全操作。
事件处理程序变为异步返回 void =>他们不能被等待。

但是，该实用程序的第一个文件打开操作（可以说：在保存函数内）也是异步的
因此，第一个等待将控制权返回给框架，该框架稍后通过第二个事件处理程序调用另一个实用程序（加载）。
负载现在尝试打开同一个文件，如果
文件现在已打开以进行保存操作，失败并出现 ACCESSDENIED 异常。

对我来说，最低限度的解决方案是通过 using 和 AsyncLock 来保护文件访问。

private static readonly AsyncLock m_lock = new AsyncLock();
...

using (await m_lock.LockAsync())
{
    file = await folder.GetFileAsync(fileName);
    IRandomAccessStream readStream = await file.OpenAsync(FileAccessMode.Read);
    using (Stream inStream = Task.Run(() => readStream.AsStreamForRead()).Result)
    {
        return (T)serializer.Deserialize(inStream);
    }
}

请注意，他的锁基本上只用一把锁就锁定了实用程序的所有文件操作，这不必要地强大，但对于我的场景来说效果很好。

这里是我的测试项目：一个包含一些测试调用的 Windows 8 应用商店应用对于来自 http://winrtstoragehelper.codeplex.com/ 和我的修改版本，它使用 斯蒂芬·托布。

我还可以推荐这个链接吗：
http://www.hanselman.com/blog/ComparingTwoTechniquesInNETAsynchronousCoordinationPrimitives.aspx

Answer 6

Stephen Taub 已经实现了此问题的解决方案，请参阅 构建异步协调原语，第 7 部分：AsyncReaderWriterLock。

斯蒂芬·陶布（Stephen Taub）在业界享有盛誉，因此他写的任何内容都可能是可靠的。

我不会重现他在博客上发布的代码，但我将向您展示如何使用它：

/// <summary>
///     Demo class for reader/writer lock that supports async/await.
///     For source, see Stephen Taub's brilliant article, "Building Async Coordination
///     Primitives, Part 7: AsyncReaderWriterLock".
/// </summary>
public class AsyncReaderWriterLockDemo
{
    private readonly IAsyncReaderWriterLock _lock = new AsyncReaderWriterLock(); 

    public async void DemoCode()
    {           
        using(var releaser = await _lock.ReaderLockAsync()) 
        { 
            // Insert reads here.
            // Multiple readers can access the lock simultaneously.
        }

        using (var releaser = await _lock.WriterLockAsync())
        {
            // Insert writes here.
            // If a writer is in progress, then readers are blocked.
        }
    }
}

如果您想要嵌入到 .NET 框架中的方法，请改用 SemaphoreSlim.WaitAsync。您不会获得读取器/写入器锁，但您将获得经过尝试和测试的实现。

Answer 7

嗯，看起来很丑，但似乎有用。

static class Async
{
    public static Task<IDisposable> Lock(object obj)
    {
        return TaskEx.Run(() =>
            {
                var resetEvent = ResetEventFor(obj);

                resetEvent.WaitOne();
                resetEvent.Reset();

                return new ExitDisposable(obj) as IDisposable;
            });
    }

    private static readonly IDictionary<object, WeakReference> ResetEventMap =
        new Dictionary<object, WeakReference>();

    private static ManualResetEvent ResetEventFor(object @lock)
    {
        if (!ResetEventMap.ContainsKey(@lock) ||
            !ResetEventMap[@lock].IsAlive)
        {
            ResetEventMap[@lock] =
                new WeakReference(new ManualResetEvent(true));
        }

        return ResetEventMap[@lock].Target as ManualResetEvent;
    }

    private static void CleanUp()
    {
        ResetEventMap.Where(kv => !kv.Value.IsAlive)
                     .ToList()
                     .ForEach(kv => ResetEventMap.Remove(kv));
    }

    private class ExitDisposable : IDisposable
    {
        private readonly object _lock;

        public ExitDisposable(object @lock)
        {
            _lock = @lock;
        }

        public void Dispose()
        {
            ResetEventFor(_lock).Set();
        }

        ~ExitDisposable()
        {
            CleanUp();
        }
    }
}

Answer 8

我创建了一个 MutexAsyncable 类，灵感来自 Stephen Toub 的 AsyncLock 实现（讨论位于 这篇博文），它可以用作 lock 语句的直接替代同步或异步代码：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace UtilsCommon.Lib;

/// <summary>
/// Class that provides (optionally async-safe) locking using an internal semaphore.
/// Use this in place of a lock() {...} construction.
/// Bear in mind that all code executed inside the worker must finish before the next
/// thread is able to start executing it, so long-running code should be avoided inside
/// the worker if at all possible.
///
/// Example usage for sync:
/// using (mutex.LockSync()) {
///     // ... code here which is synchronous and handles a shared resource ...
///     return[ result];
/// }
///
/// ... or for async:
/// using (await mutex.LockAsync()) {
///     // ... code here which can use await calls and handle a shared resource ...
///     return[ result];
/// }
/// </summary>
public sealed class MutexAsyncable {
    #region Internal classes

    private sealed class Releaser : IDisposable {
        private readonly MutexAsyncable _toRelease;
        internal Releaser(MutexAsyncable toRelease) { _toRelease = toRelease; }
        public void Dispose() { _toRelease._semaphore.Release(); }
    }

    #endregion

    private readonly SemaphoreSlim _semaphore = new(1, 1);
    private readonly Task<IDisposable> _releaser;

    public MutexAsyncable() {
        _releaser = Task.FromResult((IDisposable)new Releaser(this));
    }

    public IDisposable LockSync() {
        _semaphore.Wait();
        return _releaser.Result;
    }

    public Task<IDisposable> LockAsync() {
        var wait = _semaphore.WaitAsync();
        if (wait.IsCompleted) { return _releaser; }
        else {
            // Return Task<IDisposable> which completes once WaitAsync does
            return wait.ContinueWith(
                (_, state) => (IDisposable)state!,
                _releaser.Result,
                CancellationToken.None,
                TaskContinuationOptions.ExecuteSynchronously,
                TaskScheduler.Default
            );
        }
    }
}

如果您使用 .NET 5+，则可以安全地使用上述代码，因为它永远不会抛出 ThreadAbortException。

我还创建了一个扩展的 SemaphoreLocker 类，其灵感来自于这个答案，它可以是一个通用的 - lock 的目的替换，可同步或异步使用。它比上面的 MutexAsyncable 效率低，并且分配更多资源，尽管它具有强制工作代码在完成后释放锁的好处（从技术上讲，返回的 IDisposable由 MutexAsyncable 无法通过调用代码释放并导致死锁）。它还具有额外的 try/finally 代码来处理 ThreadAbortException 的可能性，因此应该可以在早期的 .NET 版本中使用：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace UtilsCommon.Lib;

/// <summary>
/// Class that provides (optionally async-safe) locking using an internal semaphore.
/// Use this in place of a lock() {...} construction.
/// Bear in mind that all code executed inside the worker must finish before the next thread is able to
/// start executing it, so long-running code should be avoided inside the worker if at all possible.
///
/// Example usage:
/// [var result = ]await _locker.LockAsync(async () => {
///     // ... code here which can use await calls and handle a shared resource one-thread-at-a-time ...
///     return[ result];
/// });
///
/// ... or for sync:
/// [var result = ]_locker.LockSync(() => {
///     // ... code here which is synchronous and handles a shared resource one-thread-at-a-time ...
///     return[ result];
/// });
/// </summary>
public sealed class SemaphoreLocker : IDisposable {
    private readonly SemaphoreSlim _semaphore = new(1, 1);

    /// <summary>
    /// Runs the worker lambda in a locked context.
    /// </summary>
    /// <typeparam name="T">The type of the worker lambda's return value.</typeparam>
    /// <param name="worker">The worker lambda to be executed.</param>
    public T LockSync<T>(Func<T> worker) {
        var isTaken = false;
        try {
            do {
                try {
                }
                finally {
                    isTaken = _semaphore.Wait(TimeSpan.FromSeconds(1));
                }
            }
            while (!isTaken);
            return worker();
        }
        finally {
            if (isTaken) {
                _semaphore.Release();
            }
        }
    }

    /// <inheritdoc cref="LockSync{T}(Func{T})" />
    public void LockSync(Action worker) {
        var isTaken = false;
        try {
            do {
                try {
                }
                finally {
                    isTaken = _semaphore.Wait(TimeSpan.FromSeconds(1));
                }
            }
            while (!isTaken);
            worker();
        }
        finally {
            if (isTaken) {
                _semaphore.Release();
            }
        }
    }

    /// <summary>
    /// Runs the worker lambda in an async-safe locked context.
    /// </summary>
    /// <typeparam name="T">The type of the worker lambda's return value.</typeparam>
    /// <param name="worker">The worker lambda to be executed.</param>
    public async Task<T> LockAsync<T>(Func<Task<T>> worker) {
        var isTaken = false;
        try {
            do {
                try {
                }
                finally {
                    isTaken = await _semaphore.WaitAsync(TimeSpan.FromSeconds(1));
                }
            }
            while (!isTaken);
            return await worker();
        }
        finally {
            if (isTaken) {
                _semaphore.Release();
            }
        }
    }

    /// <inheritdoc cref="LockAsync{T}(Func{Task{T}})" />
    public async Task LockAsync(Func<Task> worker) {
        var isTaken = false;
        try {
            do {
                try {
                }
                finally {
                    isTaken = await _semaphore.WaitAsync(TimeSpan.FromSeconds(1));
                }
            }
            while (!isTaken);
            await worker();
        }
        finally {
            if (isTaken) {
                _semaphore.Release();
            }
        }
    }

    /// <summary>
    /// Releases all resources used by the current instance of the SemaphoreLocker class.
    /// </summary>
    public void Dispose() {
        _semaphore.Dispose();
    }
}

Answer 9

我确实尝试使用 Monitor （下面的代码），它似乎可以工作，但有一个问题......当你有多个线程时，它会给出......

System.Threading.SynchronizationLockException 从未同步的代码块调用对象同步方法。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace MyNamespace
{
    public class ThreadsafeFooModifier : 
    {
        private readonly object _lockObject;

        public async Task<FooResponse> ModifyFooAsync()
        {
            FooResponse result;
            Monitor.Enter(_lockObject);
            try
            {
                result = await SomeFunctionToModifyFooAsync();
            }
            finally
            {
                Monitor.Exit(_lockObject);
            }
            return result;
        }
    }
}

在此之前，我只是这样做，但它是在 ASP.NET 控制器中，因此导致了死锁。

public async Task<FooResponse> ModifyFooAsync()
{
    lock(lockObject)
    {
        return SomeFunctionToModifyFooAsync.Result;
    }
}

Answer 10

我有自己的 AsyncLock 类。
我将其设为 IDisposable，因此它可以使用 using 块。
（idispose中信号量的解锁确保出现异常时它也会被解锁，而不需要try-finally）

namespace Test
{


    public abstract class AsyncLock
    : System.IAsyncDisposable
    {
        private readonly System.Threading.SemaphoreSlim m_semaphore;


        protected AsyncLock(System.Threading.SemaphoreSlim semaphore)
        {
            this.m_semaphore = semaphore;
        } // End Constructor 


        private class InternalAsyncSemaphoreSlimWrapper
            : AsyncLock
        {
            public InternalAsyncSemaphoreSlimWrapper(System.Threading.SemaphoreSlim semaphore)
               : base(semaphore)
            { } // End Constructor 

        } // End Class InternalAsyncSemaphoreSlimWrapper 


        private async System.Threading.Tasks.Task AcquireAsync()
        {
            await this.m_semaphore.WaitAsync();  // Asynchronously wait for the semaphore
        } // End Task AcquireAsync 


        public static async System.Threading.Tasks.Task<AsyncLock> LockAsync(System.Threading.SemaphoreSlim semaphore)
        {
            InternalAsyncSemaphoreSlimWrapper wrapper = new InternalAsyncSemaphoreSlimWrapper(semaphore);
            await wrapper.AcquireAsync();

            return wrapper;
        } // End Function LockAsync 


        async System.Threading.Tasks.ValueTask System.IAsyncDisposable.DisposeAsync()
        {
            this.m_semaphore.Release();  // Release the semaphore when disposed
            await System.Threading.Tasks.Task.CompletedTask;
        } // End Task DisposeAsync 


        internal static async System.Threading.Tasks.Task Test()
        {
            // private static readonly System.Threading.SemaphoreSlim s_consoleSemaphore = new System.Threading.SemaphoreSlim(1, 1);
            System.Threading.SemaphoreSlim s_consoleSemaphore = new System.Threading.SemaphoreSlim(1, 1);

            // because lock BLOCKS the thread when it waits 
            await using (AsyncLock consoleLocker = await AsyncLock.LockAsync(s_consoleSemaphore))
            {
                System.Console.WriteLine("inside the lock !");
            } // End Using consoleLocker 

        } // End Task Test 


    } // End Class AsyncLock 


} // End Namespace 

然后可以按如下方式使用

private static readonly System.Threading.SemaphoreSlim s_consoleSemaphore = 
  new System.Threading.SemaphoreSlim(1, 1);

internal static async System.Threading.Tasks.Task TestAsync()
{
    // no lock possible because lock BLOCKS the thread when it waits 
    // semaphore does not 
    await using (AsyncLock consoleLocker = await AsyncLock.LockAsync(s_consoleSemaphore))
    {
        await System.Console.Out.WriteLineAsync("inside the lock !");
    } // End Using consoleLocker 

} // End Task TestAsync 

如您所见，只需替换lock中的new object()与 new SemaphoreSlim(1, 1) 的

lock-语句进行比较：

private static readonly object s_consoleLock = new object();

internal static void Test()
{
    // no lock possible because lock BLOCKS the thread when it waits 
    // semaphore does not 
    lock(s_consoleLock)
    {
        System.Console.WriteLine("inside the lock !");
    } // End lock 

} // End Task Test