允许一次只调用一个实例的异步方法答案

【问题标题】：Allow async method to be called only one instance at a time允许一次只调用一个实例的异步方法
【发布时间】：2020-10-19 22:11:49
【问题描述】：

我有一个不能同时在多个线程中执行的方法（它写入文件）。我不能使用lock，因为方法是async。如何避免在另一个线程中调用该方法？程序应该等待上一次调用完成（也是异步的），而不是第二次调用它。

例如，使用以下代码创建一个新的 C# 控制台应用程序：

using System;
using System.IO;
using System.Threading.Tasks;
namespace ConsoleApplication1 {
    internal class Program {

        private static void Main () {
            CallSlowStuff();
            CallSlowStuff();
            Console.ReadKey();
        }

        private static async void CallSlowStuff () {
            try {
                await DoSlowStuff();
                Console.WriteLine("Done!");
            }
            catch (Exception e) {
                Console.WriteLine(e.Message);
            }
        }

        private static async Task DoSlowStuff () {
            using (File.Open("_", FileMode.Create, FileAccess.Write, FileShare.None)) {
                for (int i = 0; i < 10; i++) {
                    await Task.Factory.StartNew(Console.WriteLine, i);
                    await Task.Delay(100);
                }
            }
        }
    }
}

在本例中，第二次调用CallSlowStuff 会引发异常，因为它无法访问已打开的文件。添加lock 不是一种选择，因为lock 和async 不能混合使用。（Main 方法应该被认为是不可更改的。在实际应用中，CallSlowStuff 是一个可以在任何地方调用的接口方法。）

问题： 如何在不阻塞主线程的情况下，对CallSlowStuff 进行后续调用等待当前正在运行的调用完成？可以只使用 async/await 和任务（也许还有 Rx）来完成吗？

【问题讨论】：

顺便说一句，你真的要让你的方法async void吗？这通常是个坏主意，除非它是和事件处理程序。
@svick "Async" 方法链必须在某处停止。如果我创建CallSlowStuffasync Task，那么我将在Main 方法中收到编译器警告。您对如何完全避免async void 有什么建议吗？甚至可能吗？我对此感到疑惑，但没有找到任何解决方案。
这取决于您的应用程序的类型。如果你真的有一个控制台应用程序，正确的解决方案是为返回的Task 同步Wait()。如果它是一个 GUI 应用程序，那么 async void 事件处理程序将是正确的解决方案。在 ASP.NET MVC 中，链不必结束，因为控制器方法可以返回 Task。

标签： c# .net locking task-parallel-library async-await

【解决方案1】：

您需要某种异步锁。 Stephen Toub 有一个完整的series of articles about building async synchronization primitives（包括AsyncLock）。 AsyncLock 的一个版本也包含在 Stephen Cleary 的 AsyncEx library 中。

但可能更简单的解决方案是使用内置的SemaphoreSlim，它确实支持异步等待：

private static SemaphoreSlim SlowStuffSemaphore = new SemaphoreSlim(1, 1);

private static async void CallSlowStuff () {
    await SlowStuffSemaphore.WaitAsync();
    try {
        await DoSlowStuff();
        Console.WriteLine("Done!");
    }
    catch (Exception e) {
        Console.WriteLine(e.Message);
    }
    finally {
        SlowStuffSemaphore.Release();
    }
}

【讨论】：

美丽。 SemaphoreSlim 解决了我的并发问题。

【解决方案2】：

我会考虑更改CallSlowStuff 的方法体以将消息发布到TPL DataFlow ActionBlock，并将其配置为单一并行度：

所以在某处保留一个 ActionBlock：

ActionBlock actionBlock = 
    new ActionBlock<object>(
         (Func<object,Task>)CallActualSlowStuff,
         new ExecutionDataflowBlockOptions(){MaxDegreeOfParallelism=1});

现在：

public void CallSlowStuff()
{
    actionBlock.Post(null);
}

private async Task CallActualSlowStuff(object _)
{
    using (File.Open("_", FileMode.Create, FileAccess.Write, FileShare.None)) {
        for (int i = 0; i < 10; i++) {
            await Task.Factory.StartNew(Console.WriteLine, i);
            await Task.Delay(100);
        }
    }
}

【讨论】：

Main 方法是不可更改的。请阅读示例代码后的说明。
@Athari，假设您正在寻找某种队列，在我看来，DataFlow 在这里是合适的。看看我修改后的答案。
虽然这可行，但对我来说，这种解决方案感觉太复杂了。

【解决方案3】：

您可以在这种情况下使用信号量，请参阅http://msdn.microsoft.com/en-us/library/system.threading.semaphore.aspx

类似：

private Semaphore sem = new Semaphore(1, 1);

private static async Task DoSlowStuff () {
  sem.WaitOne();
  // your stuff here
  sem.Release();
}

【讨论】：

那会同步地等待，这在async方法中是个坏事。