Question

我想拥有一个接收Task<bool>并在X个任务中运行它的功能。

为此，我编写了以下代码：

public static class RetryComponent
{
    public static async Task RunTasks(Func<Task<bool>> action, int tasks, int retries, string method)
    {
        // Running everything
        var tasksPool = Enumerable.Range(0, tasks).Select(i => DoWithRetries(action, retries, method)).ToArray();
        await Task.WhenAll(tasksPool);
    }

    private static async Task<bool> DoWithRetries(Func<Task<bool>> action, int retryCount, string method)
    {
        while (true)
        {
            if (retryCount <= 0)
                return false;

            try
            {
                bool res = await action();
                if (res)
                    return true;
            }
            catch (Exception e)
            {
                // Log it
            }

            retryCount--;
            await Task.Delay(200); // retry in 200
        }
    }
}

以及以下执行代码：

BlockingCollection<int> ints = new BlockingCollection<int>();
foreach (int i in Enumerable.Range(0, 100000))
{
    ints.Add(i);
}
ints.CompleteAdding();

int taskId = 0;
var enumerable = new AsyncEnumerable<int>(async yield =>
{
    await RetryComponent.RunTasks(async () =>
    {
        try
        {
            int myTaskId = Interlocked.Increment(ref taskId);

            // usually there are async/await operations inside the while loop, this is just an example

            while (!ints.IsCompleted)
            {
                int number = ints.Take();

                Console.WriteLine($"Task {myTaskId}: {number}");
                await yield.ReturnAsync(number);
            }
        }
        catch (InvalidOperationException)
        {
            return true;
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            throw;
        }

        return true;
    }, 10, 1, MethodBase.GetCurrentMethod().Name);
});

await enumerable.ForEachAsync(number =>
{
    Console.WriteLine(number);
});

AsyncEnumerable来自System.Collections.Async。

控制台显示任务10：X（其中x是列表中的数字..）。

当我移除AsyncEnumerable时，一切都会按预期进行（所有任务正在打印，执行结束）。由于某些原因，我无法长时间找到，使用AsyncEnumerable只会破坏一切（在我的主要代码中，我需要使用AsyncEnumerable ..可伸缩性……）意味着该代码永远不会停止，只有最后一个任务（10）正在打印。当我添加更多日志时，我看到任务1-9永远不会完成。

因此，为了澄清问题，我想让多个任务执行异步操作，并将结果产生给充当管道的单个AsyncEnumerable对象。（这就是主意。）

Answer 1

问题是，普查员/发电机模式是连续的，但你正在试图做多生产，单消费模式。由于您使用嵌套的匿名函数，并且堆栈溢出不会显示行号，因此很难准确描述我要指代的代码的哪一部分，但是无论如何我都会尝试。

这AsyncEnumerable工作基本上是等待生产者以产生一个值，然后等待消费者使用的值的方式，然后重复。它不支持生产者和消费者的运行速度不同，所以为什么我说这种模式是连续的。它没有生产项目only the current value的队列。 ReturnAsync does not wait为消费者使用的值，而不是你应该等待它返回，它给你一个信号，表明它准备的任务。因此，我们可以得出结论，它不是线程安全的。

但是，RetryComponent.RunTasks并行运行10个任务，该代码调用yield.ReturnAsync，而无需检查是否有人已经调用了它，以及是否已经完成该任务。由于Yield类仅存储当前值，因此您的10个并发任务将覆盖当前值，而无需等待Yield对象为新值做好准备，因此9个任务会丢失并且永远不会等待。由于这9个任务从未等待，因此方法永远不会完成，Task.WhenAll也永远不会返回，整个调用堆栈中的任何其他方法也不会这样做。

I created an issue on github提出他们改善其库抛出异常时发生这种情况。如果他们实现了，您的catch块会将消息写入控制台并重新抛出错误，使任务处于错误状态，这将允许task.WhenAll完成，因此程序不会挂起。

您可以使用多线程同步的API，以确保在同一时间只调用一个任务yield.ReturnAsync，并等待返回任务。或者你可以尽量避免使用多生产模式作为一个生产者可以很容易地枚举。否则，您将需要完全重新考虑如何实现多生产者模式。我建议TPL Dataflow这是内置到.NET Core和在.NET Framework作为一个NuGet包。

Answer 2

@zivkan关于顺序生产者模式绝对正确。如果您希望为单个流拥有并发的生产者，仍然可以使用AsyncEnumerable库来实现，但是需要一些额外的代码。

以下是一个解决方案的示例，它可以解决并行生产者和使用者（在这种情况下只有一个使用者）的问题：

        static void Main(string[] args)
        {
            var e = new AsyncEnumerable<int>(async yield =>
            {
                var threadCount = 10;
                var maxItemsOnQueue = 20;

                var queue = new ConcurrentQueue<int>();
                var consumerLimiter = new SemaphoreSlim(initialCount: 0, maxCount: maxItemsOnQueue + 1);
                var produceLimiter = new SemaphoreSlim(initialCount: maxItemsOnQueue, maxCount: maxItemsOnQueue);

                // Kick off producers
                var producerTasks = Enumerable.Range(0, threadCount)
                    .Select(index => Task.Run(() => ProduceAsync(queue, produceLimiter, consumerLimiter)));

                // When production ends, send a termination signal to the consumer.
                var endOfProductionTask = Task.WhenAll(producerTasks).ContinueWith(_ => consumerLimiter.Release());

                // The consumer loop.
                while (true)
                {
                    // Wait for an item to be produced, or a signal for the end of production.
                    await consumerLimiter.WaitAsync();

                    // Get a produced item.
                    if (queue.TryDequeue(out var item))
                    {
                        // Tell producers that they can keep producing.
                        produceLimiter.Release();
                        // Yield a produced item.
                        await yield.ReturnAsync(item);
                    }
                    else
                    {
                        // If the queue is empty, the production is over.
                        break;
                    }
                }
            });

            e.ForEachAsync((item, index) => Console.WriteLine($"{index + 1}: {item}")).Wait();
        }

        static async Task ProduceAsync(ConcurrentQueue<int> queue, SemaphoreSlim produceLimiter, SemaphoreSlim consumerLimiter)
        {
            var rnd = new Random();
            for (var i = 0; i < 10; i++)
            {
                await Task.Delay(10);
                var value = rnd.Next();

                await produceLimiter.WaitAsync(); // Wait for the next production slot
                queue.Enqueue(value); // Produce item on the queue
                consumerLimiter.Release(); // Notify the consumer
            }
        }

C＃AsyncEnumerable运行/等待多个任务从未完成

2 个答案: