Parallel.ForEach vs Task.Run und Task.WhenAll

Was sind die Unterschiede zwischen der Verwendung von Parallel.ForEach oder Task.Run (), um eine Reihe von Aufgaben asynchron zu starten?

Version 1:

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

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

In diesem Fall wartet die zweite Methode asynchron auf den Abschluss der Aufgaben, anstatt sie zu blockieren.

Jedoch gibt es einen Nachteil verwenden Task.Runin einer schlaufen mit Parallel.ForEach, gibt es eine , Partitionerdie zu vermeiden , erstellt wird , mehr Aufgaben als nötig zu machen. Task.RunEs wird immer eine einzelne Aufgabe pro Element erstellt (da Sie dies tun), aber die ParallelKlassenstapel funktionieren, sodass Sie weniger Aufgaben als die gesamten Arbeitselemente erstellen. Dies kann zu einer erheblich besseren Gesamtleistung führen, insbesondere wenn der Schleifenkörper einen geringen Arbeitsaufwand pro Element aufweist.

In diesem Fall können Sie beide Optionen kombinieren, indem Sie Folgendes schreiben:

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

Beachten Sie, dass dies auch in dieser kürzeren Form geschrieben werden kann:

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

Die erste Version blockiert synchron den aufrufenden Thread (und führt einige der Aufgaben darauf aus).
Wenn es sich um einen UI-Thread handelt, friert dies die UI ein.

Die zweite Version führt die Aufgaben asynchron im Thread-Pool aus und gibt den aufrufenden Thread frei, bis sie fertig sind.

Es gibt auch Unterschiede bei den verwendeten Planungsalgorithmen.

Beachten Sie, dass Ihr zweites Beispiel auf gekürzt werden kann

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

Am Ende tat ich dies, da es sich leichter zu lesen anfühlte:

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

Ich habe gesehen, dass Parallel.ForEach unangemessen verwendet wurde, und ich dachte, ein Beispiel in dieser Frage würde helfen.

Wenn Sie den folgenden Code in einer Konsolen-App ausführen, sehen Sie, wie die in Parallel.ForEach ausgeführten Aufgaben den aufrufenden Thread nicht blockieren. Dies kann in Ordnung sein, wenn Sie sich nicht für das Ergebnis interessieren (positiv oder negativ), aber wenn Sie das Ergebnis benötigen, sollten Sie sicherstellen, dass Sie Task.WhenAll verwenden.

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}]");
        }
    }
}

Hier ist das Ergebnis:

Fazit:

Wenn Sie Parallel.ForEach mit einer Aufgabe verwenden, wird der aufrufende Thread nicht blockiert. Wenn Sie sich für das Ergebnis interessieren, warten Sie auf die Aufgaben.

~ Prost