Parallel.ForEach 与 Task.Run 和 Task.WhenAll

Question

使用 Parallel.ForEach 或 Task.Run() 异步启动一组任务有什么区别？

版本 1：

List<string> strings = new List<string> { "s1", "s2", "s3" };
Parallel.ForEach(strings, s =>
{
    DoSomething(s);
});

版本 2：

List<string> strings = new List<string> { "s1", "s2", "s3" };
List<Task> Tasks = new List<Task>();
foreach (var s in strings)
{
    Tasks.Add(Task.Run(() => DoSomething(s)));
}
await Task.WhenAll(Tasks);

Answer 1

第一个版本将同步阻塞调用线程（并在其上运行一些任务）。
如果是 UI 线程，这将冻结 UI。

第二个版本将在线程池中异步运行任务并释放调用线程，直到它们完成。

使用的调度算法也有区别。

请注意，您的第二个示例可以缩短为

await Task.WhenAll(strings.Select(s => Task.Run(() => DoSomething(s))));

Answer 2

在这种情况下，第二种方法将异步等待任务完成而不是阻塞。

但是，在循环中使用Task.Run 有一个缺点——使用Parallel.ForEach，会创建一个Partitioner，以避免执行不必要的任务。 Task.Run 将始终为每个项目创建一个任务（因为您正在这样做），但 Parallel 类批处理工作，因此您创建的任务比总工作项目少。这可以提供显着更好的整体性能，尤其是在循环体每个项目的工作量很小的情况下。

如果是这种情况，您可以通过以下方式组合这两个选项：

await Task.Run(() => Parallel.ForEach(strings, s =>
{
    DoSomething(s);
}));

请注意，这也可以写成更短的形式：

await Task.Run(() => Parallel.ForEach(strings, DoSomething));

Answer 3

我最终这样做了，因为它更容易阅读：

  List<Task> x = new List<Task>();
  foreach(var s in myCollectionOfObject)
  {
      // Note there is no await here. Just collection the Tasks
      x.Add(s.DoSomethingAsync());
  }
  await Task.WhenAll(x);

Answer 4

我看到 Parallel.ForEach 使用不当，我认为这个问题中的一个例子会有所帮助。

当您在控制台应用程序中运行以下代码时，您将看到在 Parallel.ForEach 中执行的任务如何不会阻塞调用线程。如果您不关心结果（正面或负面），这可能没问题，但如果您确实需要结果，则应确保使用 Task.WhenAll。

using System;
using System.Linq;
using System.Threading.Tasks;

namespace ParrellelEachExample
{
    class Program
    {
        static void Main(string[] args)
        {
            var indexes = new int[] { 1, 2, 3 };

            RunExample((prefix) => Parallel.ForEach(indexes, (i) => DoSomethingAsync(i, prefix)),
                "Parallel.Foreach");

            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("*You'll notice the tasks haven't run yet, because the main thread was not blocked*");
            Console.WriteLine("Press any key to start the next example...");
            Console.ReadKey();
            
            RunExample((prefix) => Task.WhenAll(indexes.Select(i => DoSomethingAsync(i, prefix)).ToArray()).Wait(),
                "Task.WhenAll");
            Console.WriteLine("All tasks are done.  Press any key to close...");
            Console.ReadKey();
        }

        static void RunExample(Action<string> action, string prefix)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Console.WriteLine($"{Environment.NewLine}Starting '{prefix}'...");
            action(prefix);
            Console.WriteLine($"{Environment.NewLine}Finished '{prefix}'{Environment.NewLine}");
        }
        

        static async Task DoSomethingAsync(int i, string prefix)
        {
            await Task.Delay(i * 1000);
            Console.WriteLine($"Finished: {prefix}[{i}]");
        }
    }
}

结果如下：

结论：

将 Parallel.ForEach 与 Task 一起使用不会阻塞调用线程。如果您关心结果，请确保等待任务。