[英]C# AsyncEnumerable running/awaiting multiple tasks never finishes
我想要一个接收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对象。 (这就是主意。)
问题在于枚举器/生成器模式是顺序的,但是您正在尝试创建多生产者,单消费者模式。 由于您使用嵌套的匿名函数,并且堆栈溢出不会显示行号,因此很难准确描述我要指代的代码的哪一部分,但是无论如何我都会尝试。
AsyncEnumerable的工作方式基本上是等待生产者产生一个值,然后等待使用者使用该值,然后重复。 它不支持生产者和消费者以不同的速度运行,因此为什么我说这种模式是连续的。 它没有生产项目的队列, 只有当前值 。 ReturnAsync不等待使用者使用该值,而是应该等待它返回的任务,这会向您发出信号,表明已准备就绪。 因此,我们可以得出结论,它不是线程安全的。
但是, RetryComponent.RunTasks
并行运行10个任务,该代码调用yield.ReturnAsync
而不检查是否有人已经调用它,以及是否已经完成该任务。 由于Yield类仅存储当前值,因此您的10个并发任务会覆盖当前值,而无需等待Yield
对象准备好新值,因此9个任务会丢失并且永远不会等待。 由于这9个任务从未等待,因此方法永远不会完成,而Task.WhenAll
永远不会返回,并且整个调用堆栈中的任何其他方法也不会执行。
我在github上创建了一个问题,提议他们改进其库以在发生这种情况时引发异常。 如果他们实现了,则catch块会将消息写入控制台并重新抛出错误,使任务处于故障状态,这将允许task.WhenAll
完成,因此程序不会挂起。
您可以使用多线程同步API来确保一次仅调用一项任务yield.ReturnAsync
并等待返回任务。 或者您可以避免使用多生产者模式,因为单个生产者可以轻松地成为枚举器。 否则,您将需要完全重新考虑如何实现多生产者模式。 我建议TPL Dataflow内置于.NET Core中,并作为NuGet包在.NET Framework中提供。
@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
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.