Paralelo.ForEach vs Task.Run y ​​Task.WhenAll

¿Cuáles son las diferencias entre usar Parallel.ForEach o Task.Run () para iniciar un conjunto de tareas de forma asincrónica?

Versión 1:

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

Versión 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);

En este caso, el segundo método esperará asincrónicamente a que se completen las tareas en lugar de bloquearlas.

Sin embargo, hay una desventaja de usar Task.Runen un bucle Parallel.ForEach: hay una Partitionerque se crea para evitar realizar más tareas de las necesarias. Task.Runsiempre realizará una única tarea por elemento (ya que está haciendo esto), pero los Parallellotes de clase funcionan, por lo que crea menos tareas que el total de elementos de trabajo. Esto puede proporcionar un rendimiento general significativamente mejor, especialmente si el cuerpo del bucle tiene una pequeña cantidad de trabajo por elemento.

Si este es el caso, puede combinar ambas opciones escribiendo:

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

Tenga en cuenta que esto también se puede escribir en esta forma más corta:

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

La primera versión bloqueará sincrónicamente el hilo de llamada (y ejecutará algunas de las tareas en él).
Si es un subproceso de interfaz de usuario, esto congelará la interfaz de usuario.

La segunda versión ejecutará las tareas de forma asincrónica en el grupo de subprocesos y liberará el subproceso de llamada hasta que estén listas.

También hay diferencias en los algoritmos de programación utilizados.

Tenga en cuenta que su segundo ejemplo se puede acortar a

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

Terminé haciendo esto, ya que me pareció más fácil de leer:

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

He visto Parallel.ForEach usado inapropiadamente, y pensé que un ejemplo en esta pregunta ayudaría.

Cuando ejecute el código a continuación en una aplicación de consola, verá cómo las tareas ejecutadas en Parallel.ForEach no bloquean el hilo de llamada. Esto podría estar bien si no le importa el resultado (positivo o negativo) pero si necesita el resultado, debe asegurarse de usar 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}]");
        }
    }
}

Aquí está el resultado:

Conclusión:

El uso de Parallel.ForEach con una tarea no bloqueará el hilo de llamada. Si te importa el resultado, asegúrate de esperar las tareas.

~ Saludos