Parallel.ForEach vs Task.Factory.StartNew

¿Cuál es la diferencia entre los fragmentos de código a continuación? ¿No usarán ambos hilos de threadpool?

Por ejemplo, si quiero llamar a una función para cada elemento de una colección,

Parallel.ForEach<Item>(items, item => DoSomething(item));

vs

foreach(var item in items)
{
  Task.Factory.StartNew(() => DoSomething(item));
}

La primera es una opción mucho mejor.

Parallel.ForEach, internamente, utiliza a Partitioner<T>para distribuir su colección en elementos de trabajo. No realizará una tarea por elemento, sino que la procesará por lotes para reducir la sobrecarga involucrada.

La segunda opción programará un solo Taskpor artículo en su colección. Si bien los resultados serán (casi) los mismos, esto introducirá muchos más gastos generales de los necesarios, especialmente para grandes colecciones, y hará que los tiempos de ejecución generales sean más lentos.

Para su información: el Partitioner utilizado se puede controlar mediante el uso de las sobrecargas apropiadas para Parallel.ForEach , si así lo desea. Para más detalles, vea Particionadores personalizados en MSDN.

La principal diferencia, en tiempo de ejecución, es que el segundo actuará de forma asíncrona. Esto se puede duplicar usando Parallel.ForEach haciendo:

Task.Factory.StartNew( () => Parallel.ForEach<Item>(items, item => DoSomething(item)));

Al hacer esto, aún aprovecha los particionadores, pero no bloquee hasta que se complete la operación.

Hice un pequeño experimento para ejecutar un método "1,000,000,000 (mil millones)" veces con "Paralelo.Para" y uno con objetos "Tarea".

Medí el tiempo del procesador y encontré Parallel más eficiente. Paralelo: divide su tarea en pequeños elementos de trabajo y los ejecuta en todos los núcleos de forma paralela de manera óptima. Al crear muchos objetos de tarea (FYI TPL utilizará la agrupación de subprocesos internamente) moverá cada ejecución en cada tarea creando más estrés en el cuadro, lo que es evidente en el experimento a continuación.

También creé un pequeño video que explica TPL básico y también demostré cómo Parallel.For utiliza su núcleo de manera más eficiente http://www.youtube.com/watch?v=No7QqSc5cl8 en comparación con las tareas y subprocesos normales.

Experimento 1

Parallel.For(0, 1000000000, x => Method1());

Experimento 2

for (int i = 0; i < 1000000000; i++)
{
    Task o = new Task(Method1);
    o.Start();
}

Parallel.ForEach optimizará (puede que ni siquiera inicie nuevos subprocesos) y bloqueará hasta que finalice el bucle, y Task.Factory creará explícitamente una nueva instancia de tarea para cada elemento, y regresará antes de que finalicen (tareas asincrónicas). Paralelo: Foreach es mucho más eficiente.

En mi opinión, el escenario más realista es cuando las tareas tienen que completar una operación pesada. El enfoque de Shivprasad se centra más en la creación de objetos / asignación de memoria que en la computación misma. Hice una investigación llamando al siguiente método:

public static double SumRootN(int root)
{
    double result = 0;
    for (int i = 1; i < 10000000; i++)
        {
            result += Math.Exp(Math.Log(i) / root);
        }
        return result; 
}

La ejecución de este método lleva aproximadamente 0.5 segundos.

Lo llamé 200 veces usando Paralelo:

Parallel.For(0, 200, (int i) =>
{
    SumRootN(10);
});

Luego lo llamé 200 veces usando la forma tradicional:

List<Task> tasks = new List<Task>() ;
for (int i = 0; i < loopCounter; i++)
{
    Task t = new Task(() => SumRootN(10));
    t.Start();
    tasks.Add(t);
}

Task.WaitAll(tasks.ToArray()); 

Primer caso completado en 26656 ms, el segundo en 24478 ms. Lo repetí muchas veces. Cada vez que el segundo enfoque es marginalmente más rápido.