Parallel.ForEach vs Task.Run и Task.WhenAll

В чем разница между использованием 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);

В этом случае второй метод будет асинхронно ожидать завершения задач вместо блокировки.

Тем не менее, есть недостаток для использования Task.Runв цикле Parallel.ForEach- с, Partitionerкоторый создается, чтобы избежать выполнения большего количества задач, чем необходимо. Task.Runвсегда будет выполнять одну задачу для каждого элемента (поскольку вы это делаете), но Parallelпакеты классов работают так, что вы создаете меньше задач, чем всего рабочих элементов. Это может обеспечить значительно лучшую общую производительность, особенно если тело цикла выполняет небольшое количество работы на элемент.

Если это так, вы можете объединить оба варианта, написав:

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

Обратите внимание, что это также может быть записано в этой более короткой форме:

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

Первая версия будет синхронно блокировать вызывающий поток (и запускать на нем некоторые задачи).
Если это поток пользовательского интерфейса, это замораживает пользовательский интерфейс.

Вторая версия будет запускать задачи асинхронно в пуле потоков и освобождать вызывающий поток, пока они не будут выполнены.

Существуют также различия в используемых алгоритмах планирования.

Обратите внимание, что ваш второй пример может быть сокращен до

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

Я закончил тем, что сделал это, поскольку это было легче читать:

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

Я видел, что 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 с задачей не блокирует вызывающий поток. Если вы заботитесь о результате, обязательно дождитесь выполнения заданий.

~ Приветствия