Parallel.ForEach 阻塞调用方法

Question

我遇到了Parallel.ForEach 的问题。我编写了简单的应用程序，将要下载的文件名添加到队列中，然后使用 while 循环遍历队列，一次下载一个文件，然后在下载文件后，调用另一个异步方法从下载的对象中创建对象memoryStream。该方法的返回结果不等待，直接丢弃，立即开始下一次下载。如果我在对象创建中使用简单的foreach，一切正常 - 在继续下载的同时创建对象。但是，如果我想加快对象创建过程并使用Parallel.ForEach，它将停止下载过程，直​​到创建对象。 UI 是完全响应的，但它不会下载下一个对象。我不明白为什么会发生这种情况 - Parallel.ForEach 在 await Task.Run() 内部，据我对异步编程的有限了解，这应该可以解决问题。谁能帮我理解为什么它会阻止第一种方法以及如何避免它？

这是一个小示例：

public async Task DownloadFromCloud(List<string> constructNames)
{
    _downloadDataQueue = new Queue<string>();
    var _gcsClient = StorageClient.Create();

    foreach (var item in constructNames)
    {
        _downloadDataQueue.Enqueue(item);
    }

    while (_downloadDataQueue.Count > 0)
    {
        var memoryStream = new MemoryStream();
        await _gcsClient.DownloadObjectAsync("companyprojects",
            _downloadDataQueue.Peek(), memoryStream);
        memoryStream.Position = 0;
        _ = ReadFileXml(memoryStream);
        _downloadDataQueue.Dequeue();
    }
}

private async Task ReadFileXml(MemoryStream memoryStream)
{
    var reader = new XmlReader();
    var properties = reader.ReadXmlTest(memoryStream);
    await Task.Run(() =>
    {
        var entityList = new List<Entity>();
        foreach (var item in properties)
        {
            entityList.Add(CreateObjectsFromDownloadedProperties(item));
        }
        //Parallel.ForEach(properties item =>
        //{
        //    entityList.Add(CreateObjectsFromDownloadedProperties(item));
        //});
    });
}

---

编辑
这是简化的对象创建方法：

public Entity CreateObjectsFromDownloadedProperties(RebarProperties properties)
{
    var path = new LinearPath(properties.Path);
    var section = new Region(properties.Region);
    var sweep = section.SweepAsMesh(path, 1);
    return sweep;
}

Answer 1

该方法的返回结果不等待，直接丢弃，立即开始下一次下载。

这也很危险。 “一劳永逸”的意思是“我不在乎此操作何时完成，或者它是否完成。只需丢弃所有异常，因为我不在乎。”因此，一劳永逸应该在实践中极为罕见。这里不合适。

UI 完全响应，但它不会下载下一个对象。

我不知道为什么它会阻止下载，但是切换到Parallel.ForEach 肯定会出现问题：List<T>.Add 不是线程安全的。

private async Task ReadFileXml(MemoryStream memoryStream)
{
    var reader = new XmlReader();
    var properties = reader.ReadXmlTest(memoryStream);
    await Task.Run(() =>
    {
        var entityList = new List<Entity>();
        Parallel.ForEach(properties, item =>
        {
            var itemToAdd = CreateObjectsFromDownloadedProperties(item);
            lock (entityList) { entityList.Add(itemToAdd); }
        });
    });
}

一个提示：如果你有一个结果值，PLINQ 通常比Parallel 更干净：

private async Task ReadFileXml(MemoryStream memoryStream)
{
    var reader = new XmlReader();
    var properties = reader.ReadXmlTest(memoryStream);
    await Task.Run(() =>
    {
        var entityList = proeprties
            .AsParallel()
            .Select(CreateObjectsFromDownloadedProperties)
            .ToList();
    });
}

但是，代码仍然存在即发即弃的问题。

为了更好地解决问题，我建议退后一步，使用更适合“管道”式处理的东西。例如，TPL 数据流：

public async Task DownloadFromCloud(List<string> constructNames)
{
  // Set up the pipeline.
  var gcsClient = StorageClient.Create();
  var downloadBlock = new TransformBlock<string, MemoryStream>(async constructName =>
  {
    var memoryStream = new MemoryStream();
    await gcsClient.DownloadObjectAsync("companyprojects", constructName, memoryStream);
    memoryStream.Position = 0;
    return memoryStream;
  });
  var processBlock = new TransformBlock<MemoryStream, List<Entity>>(memoryStream =>
  {
    var reader = new XmlReader();
    var properties = reader.ReadXmlTest(memoryStream);
    return proeprties
        .AsParallel()
        .Select(CreateObjectsFromDownloadedProperties)
        .ToList();
  });
  var resultsBlock = new ActionBlock<List<Entity>>(entities => { /* TODO */ });
  downloadBlock.LinkTo(processBlock, new DataflowLinkOptions { PropagateCompletion = true });
  processBlock.LinkTo(resultsBlock, new DataflowLinkOptions { PropagateCompletion = true });

  // Push data into the pipeline.
  foreach (var constructName in constructNames)
    await downloadBlock.SendAsync(constructName);
  downlodBlock.Complete();

  // Wait for pipeline to complete.
  await resultsBlock.Completion;
}