如何序列化异步/等待？

Question

假设我有这个简单的 sn-p：

async void button_Click(object sender, RoutedEventArgs e)
{
    await Task.Factory.StartNew(() =>
    {
        Console.WriteLine("start");
        Thread.Sleep(5000);
        Console.WriteLine("end");
    });
}

显然，每次我按下该按钮时，都会启动一个新任务，即使之前的任务仍在运行。我将如何推迟任何新任务，直到所有以前的任务都完成？

更多细节：

在上面的示例中，每个新任务都与之前的任务相同。但是，在原始上下文中，任务顺序很重要：参数可能会改变（我可以使用DateTime.Now.Ticks“模拟”它）。 任务应该按照它们“注册”的顺序执行。具体来说，我的程序将与串行设备通信。我之前使用BlockingCollection 的后台线程完成了此操作。但是，这次有一个严格的请求/响应协议，如果可能的话，我想使用 async/await。

可能的解决方案：

我可以想象创建任务并将它们存储在一个列表中。但是我将如何执行与需求相关的任务？还是应该回到我之前使用过的基于线程的解决方案？

Answer 1

我建议使用SemaphoreSlim 进行同步。但是，您想avoid Task.Factory.StartNew（正如我在我的博客中解释的那样）和definitely avoid async void（正如我在 MSDN 文章中解释的那样）。

private SemaphoreSlim _mutex = new SemaphoreSlim(1);
async void button_Click(object sender, RoutedEventArgs e)
{
  await Task.Run(async () =>
  {
    await _mutex.WaitAsync();
    try
    {
      Console.WriteLine("start");
      Thread.Sleep(5000);
      Console.WriteLine("end");
    }
    finally
    {
      _mutex.Release();
    }
  });
}

Answer 2

您可以异步等待SemaphoreSlim，并在工作完成后释放它。不要忘记将信号量初始计数配置为1。

private static SemaphoreSlim semaphore = new SemaphoreSlim(1);

private async static void DoSomethingAsync()
{
     await semaphore.WaitAsync();
     try
     {
        await Task.Factory.StartNew(() =>
        {
            Console.WriteLine("start");
            Thread.Sleep(5000);
            Console.WriteLine("end");
        });
     }
     finally
     {
        semaphore.Release();
     }
}

private static void Main(string[] args)
{
    DoSomethingAsync();
    DoSomethingAsync();
    Console.Read();
}

Answer 3

尝试使用（默认）最大并行度为 1 的 Dataflow.ActionBlock<T> 怎么样。这样您就无需担心任何线程安全/锁定问题。

它可能看起来像：

...
var _block = new ActionBlock<bool>(async b =>
                {
                    Console.WriteLine("start");
                    await Task.Delay(5000);
                    Console.WriteLine("end");
                });
...


async void button_Click(object sender, RoutedEventArgs e)
{
    await _block.SendAsync(true);
}

您还可以将 ActionBlock 设置为接收Task 或Func<Task>，然后简单地运行/等待此输入​​。这将允许来自不同来源的多个操作排队等待。

Answer 4

我可能遗漏了一些东西，但我认为 OP 的场景不需要 SemaphoreSlim。我会按照以下方式进行。基本上，代码只是 await 在继续之前任务的前一个待处理实例（为清楚起见没有异常处理）：

// the current pending task (initially a completed stub)
Task _pendingTask = Task.FromResult<bool>(true);

async void button_Click(object sender, RoutedEventArgs e)
{
    var previousTask = _pendingTask;

    _pendingTask = Task.Run(async () =>
    {
        await previousTask;

        Console.WriteLine("start");
        Thread.Sleep(5000);
        Console.WriteLine("end");
    });

    // the following "await" is optional, 
    // you only need it if you have other things to do 
    // inside "button_Click" when "_pendingTask" is completed
    await _pendingTask;
}

[UPDATE]为了解决评论，这里有一个线程安全的版本，可以同时调用button_Click：

Task _pendingTask = Task.FromResult<bool>(true);
object _pendingTaskLock = new Object();

async void button_Click(object sender, RoutedEventArgs e)
{
    Task thisTask;

    lock (_pendingTaskLock)
    {
        var previousTask = _pendingTask;

        // note the "Task.Run" lambda doesn't stay in the lock
        thisTask = Task.Run(async () =>
        {
            await previousTask;

            Console.WriteLine("start");
            Thread.Sleep(5000);
            Console.WriteLine("end");
        });

        _pendingTask = thisTask;
    }

    await thisTask;
}