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进行后续调用，等待当前正在运行的调用完成，而不阻塞主线程？可以使用async / await和tasks（以及Rx）来完成吗？

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

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

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

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

3 个答案: