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в циклі - With 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 із завданням не блокує потоку виклику. Якщо ви піклуєтесь про результат, обов’язково дочекайтеся завдань.

~ Ура