Parallel.ForEach vs Task.Factory.StartNew

Qual è la differenza tra i frammenti di codice seguenti? Non userete entrambi i thread di threadpool?

Ad esempio, se desidero chiamare una funzione per ciascun elemento in una raccolta,

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

vs

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

La prima è un'opzione molto migliore.

Parallel.ForEach, internamente, usa a Partitioner<T>per distribuire la tua collezione in oggetti di lavoro. Non eseguirà un'attività per articolo, ma piuttosto raggruppa questo per ridurre i costi generali coinvolti.

La seconda opzione pianificherà un singolo Taskper articolo nella tua raccolta. Mentre i risultati saranno (quasi) gli stessi, questo introdurrà un sovraccarico molto maggiore del necessario, specialmente per le grandi collezioni, e rallenterà i tempi complessivi di funzionamento.

Cordiali saluti - Il partizionatore utilizzato può essere controllato usando i sovraccarichi appropriati su Parallel.ForOach , se lo si desidera. Per i dettagli, consultare Partizionatori personalizzati su MSDN.

La differenza principale, in fase di esecuzione, è che la seconda agirà in modo asincrono. Questo può essere duplicato usando Parallel.ForEach facendo:

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

In questo modo, si sfrutta comunque i partizionatori, ma non si blocca fino al completamento dell'operazione.

Ho fatto un piccolo esperimento per eseguire un metodo "1.000.000.000 (un miliardo)" volte con "Parallel.For" e uno con oggetti "Task".

Ho misurato il tempo del processore e ho trovato Parallel più efficiente. Parallelo: per suddividere l'attività in piccoli oggetti di lavoro ed eseguirli su tutti i nuclei in parallelo in modo ottimale. Durante la creazione di molti oggetti task (FYI TPL utilizzerà internamente il pool di thread), ogni esecuzione su ciascuna attività verrà spostata creando più stress nella casella, come risulta dall'esperimento di seguito.

Ho anche creato un piccolo video che spiega il TPL di base e ha anche dimostrato come Parallel.For utilizza il tuo core in modo più efficiente http://www.youtube.com/watch?v=No7QqSc5cl8 rispetto alle normali attività e discussioni.

Esperimento 1

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

Esperimento 2

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

Parallel.ForEach ottimizzerà (potrebbe anche non avviare nuovi thread) e si bloccherà fino al termine del ciclo, mentre Task.Factory creerà esplicitamente una nuova istanza di attività per ciascun elemento e tornerà prima che siano terminati (attività asincrone). Parallel.Foreach è molto più efficiente.

A mio avviso, lo scenario più realistico è quando le attività hanno un'operazione pesante da completare. L'approccio di Shivprasad si concentra più sulla creazione di oggetti / allocazione della memoria che sul calcolo stesso. Ho fatto una ricerca chiamando il seguente metodo:

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

L'esecuzione di questo metodo richiede circa 0,5 secondi.

L'ho chiamato 200 volte usando Parallel:

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

Poi l'ho chiamato 200 volte usando il vecchio stile:

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

Primo caso completato in 26656 ms, il secondo in 24478 ms. L'ho ripetuto molte volte. Ogni volta che il secondo approccio è marginalmente più veloce.