允许异步方法一次只能被调用一个实例

Question

我有一个方法，不能同时在多个线程中执行（它会写文件）。我不能使用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 的调用等待当前正在运行的调用完成，而不阻塞主线程？是否可以只使用异步/等待和任务（以及 Rx）来完成此操作？

- Athari

---

顺便问一下，您真的想将您的方法设置为“async void” 吗？除非它是事件处理程序，否则通常这是个不好的主意。 - svick

@svick，“异步”方法链必须有一个停止点。 如果我将CallSlowStuff改为“async Task”，那么在Main方法中会出现编译器警告。 您有任何建议可以完全避免“异步void”吗？ 这可能吗？ 我一直在想，但没有找到任何解决方案。 - Athari

这取决于您的应用程序类型。如果您确实有一个控制台应用程序，正确的解决方案是同步地Wait()返回的Task。如果它是GUI应用程序，则async void事件处理程序将是正确的解决方案。在ASP.NET MVC中，链不必结束，因为控制器方法可以返回Task。 - svick

Answer 1

您需要某种类型的异步锁。Stephen Toub 撰写了一整个系列文章，介绍了构建 async 同步原语的方法（包括 AsyncLock）。AsyncLock 的一个版本也包含在 Stephen Cleary 的 AsyncEx 库中。

但更简单的解决方案可能是使用内置的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();
    }
}

- svick

---

漂亮。SemaphoreSlim 解决了我的并发问题。 - xleon

Answer 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);
        }
    }
}

- spender

---

Main方法是不可更改的。请在示例代码后阅读描述。 - Athari

@Athari，假设您正在寻找某种队列，那么在这里使用DataFlow似乎是合适的。请查看我的修订答案。 - spender

虽然这个解决方案可以工作，但对我来说，它感觉过于复杂，不太适合这种情况。 - svick

Answer 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();
}

- user1079741

---

这会以同步方式等待，这在“异步”方法中是不好的。 - svick