Parallel.ForEach vs Task.Run i Task.WhenAll

Jakie są różnice między używaniem Parallel.ForEach lub Task.Run () do asynchronicznego uruchamiania zestawu zadań?

Wersja 1:

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

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

W takim przypadku druga metoda będzie asynchronicznie czekać na zakończenie zadań zamiast blokowania.

Jednak użycie Task.Runpętli ma tę wadę Parallel.ForEach, że jest Partitionertworzona, aby uniknąć wykonywania większej liczby zadań niż to konieczne. Task.Runzawsze utworzy jedno zadanie na element (ponieważ to robisz), ale Parallelpartie klas działają, więc utworzysz mniej zadań niż wszystkie elementy pracy. Może to zapewnić znacznie lepszą ogólną wydajność, zwłaszcza jeśli treść pętli wymaga niewielkiej ilości pracy na element.

W takim przypadku możesz połączyć obie opcje, pisząc:

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

Zauważ, że można to również zapisać w tej krótszej formie:

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

Pierwsza wersja będzie synchronicznie blokować wątek wywołujący (i uruchamiać na nim niektóre zadania).
Jeśli jest to wątek interfejsu użytkownika, spowoduje to zawieszenie interfejsu użytkownika.

Druga wersja będzie uruchamiać zadania asynchronicznie w puli wątków i zwalniać wątek wywołujący, dopóki nie zostaną wykonane.

Istnieją również różnice w stosowanych algorytmach planowania.

Zwróć uwagę, że drugi przykład można skrócić do

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

Skończyło się na tym, że to było łatwiejsze do odczytania:

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

Widziałem użycie Parallel.ForEach niewłaściwie i pomyślałem, że przykład w tym pytaniu może pomóc.

Po uruchomieniu poniższego kodu w aplikacji konsoli zobaczysz, jak zadania wykonywane w Parallel.ForEach nie blokują wątku wywołującego. Może to być w porządku, jeśli nie zależy Ci na wyniku (dodatnim lub ujemnym), ale jeśli potrzebujesz wyniku, powinieneś upewnić się, że używasz 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}]");
        }
    }
}

Oto wynik:

Wniosek:

Użycie Parallel.ForEach z Task nie spowoduje zablokowania wątku wywołującego. Jeśli zależy Ci na wyniku, czekaj na zadania.

~ Pozdrawiam