用 await 命名的 Mutex

Question

因此我不能在async 中使用线程仿射锁 - 在运行多个进程时如何保护我的资源？

例如，我有两个使用以下任务的进程：

 public async Task<bool> MutexWithAsync()
 {
     using (Mutex myMutex = new Mutex(false, "My mutex Name"))
     {
         try
         {
             myMutex.WaitOne();
             await DoSomething();
             return true;
         }
         catch { return false; }
         finally { myMutex.ReleaseMutex(); }
     }
 }

如果受 Mutex 保护的方法是同步的，那么上面的代码将有效，但使用 async 我会得到：

对象同步方法是从未同步的代码块中调用的。

那么命名互斥锁对异步代码没用吗？

Answer 1

您必须确保在某个线程上一致地访问互斥锁。您可以通过多种方式做到这一点：

1. 不要在持有互斥锁的关键部分使用 await
2. 在只有一个线程的 TaskScheduler 上调用互斥锁

可能是这样的：

await Task.Factory.StartNew(() => mutex.WaitOne(), myCustomTaskScheduler);

或者，您使用同步代码并将所有内容移至线程池。如果您只能访问 DoSomething 的异步版本，请考虑在其结果上调用 Task.Wait。你会在这里遭受轻微的低效率。应该没问题。

Answer 2

我在异步方法中使用命名 Mutex 来控制只有一个进程调用它。另一个进程检查命名的 Mutex 并在它无法创建新的 named Mutex 时退出。

我可以在异步方法中使用命名互斥锁，因为操作系统只保证/控制操作系统中命名对象的一个​​实例。另外，我不使用应该在线程上调用的 WaitOne/Release。

public async Task<bool> MutexWithAsync()
{
    // Create OS-wide named object. (It will not use WaitOne/Release)
    using (Mutex myMutex = new Mutex(false, "My mutex Name", out var owned))
    {
        if (owned)
        {
            // New named-object was created. We own it.
            try
            {
                await DoSomething();
                return true;
            }
            catch
            {
                return false;
            }
        }
        else
        {
            // The mutex was created by another process.
            // Exit this instance of process.
        }
    }
}

Answer 3

您可以使用二进制信号量代替互斥量。信号量不需要由获取它的同一线程释放。这里最大的缺点是如果应用程序崩溃或在 DoSomething() 中被终止，则信号量将不会被释放并且应用程序的下一个实例将挂起。见Abandoned named semaphore not released

 public async Task<bool> MutexWithAsync()
 {
     using (Semaphore semaphore = new Semaphore(1, 1, "My semaphore Name"))
     {
         try
         {
             semaphore.WaitOne();
             await DoSomething();
             return true;
         }
         catch { return false; }
         finally { semaphore.Release(); }
     }
 }

Answer 4

我为您提供了一个有趣的解决方案。现在没有时间提供代码示例，所以如果我的描述不够，请告诉我，我会尝试提供代码。

这里有两个问题。首先，正如您所指出的，AsyncMutex 没有线程亲和性。所以你不能用 Mutex 构建一个。但是，您可以使用计数为 1 的信号量构建一个，因为信号量也没有线程亲和性。在 C# 中，可以跨进程边界命名和使用 Semaphore 类。所以第一个问题很容易解决。

第二个问题是当你“锁定”这个 AsyncMutex 时不想使用阻塞调用。好吧，您可以使用 ThreadPool.RegisterWaitForSingleObject 注册一个回调，以便在信号量（a WaitHandle）发出信号时执行。这会进行“异步等待”。使用 TaskCompletionSource 用一些代码包装它，您可以相当轻松地在 AsyncMutex 上构建返回 WaitAsync 方法的任务。这两个想法应该可以相当容易地实现一个名为 AsyncMutex 的跨进程，可以在 C# 中使用。

请记住，与您会发现的其他 AsyncMutex 实现一样，这不是递归互斥锁（同一个“线程”可以多次锁定互斥锁，只要它解锁互斥锁的次数相同），所以在代码中必须注意不要导致死锁。

Answer 5

这个守卫与 async/await 完美配合：

public sealed class AsyncLock : IDisposable
{
    readonly AutoResetEvent Value;

    public AsyncLock(AutoResetEvent value, int milliseconds = Timeout.Infinite)
    {
        if (value == null)
            throw new ArgumentNullException("value");

        value.WaitOne(milliseconds);
        Value = value;
    }

    void IDisposable.Dispose()
    {
        Value.Set();
    }
}

private async Task TestProc()
{
    var guard = new AutoResetEvent(true); // Guard for resource

    using (new AsyncLock(guard)) // Lock resource
    {
        await ProcessNewClientOrders(); // Use resource
    } // Unlock resource
}