Parallel.ForEach vs Task.Factory.StartNew

Яка різниця між наведеними нижче фрагментами коду? Не будуть обидва використовувати нитки нитки?

Наприклад, якщо я хочу викликати функцію для кожного елемента колекції,

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

vs

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

Перший - набагато кращий варіант.

Parallel.ForEach, внутрішньо, використовує a Partitioner<T>для розподілу своєї колекції по робочих предметах. Він не буде виконувати одне завдання на предмет, а скоріше замість цього, щоб зменшити накладні витрати.

У другому варіанті буде заплановано одиницю Taskна предмет у колекції. Хоча результати будуть (майже) однаковими, це призведе до набагато більших витрат, ніж потрібно, особливо для великих колекцій, і призведе до того, що загальний час роботи буде повільнішим.

FYI - Партнером, що використовується, можна керувати, використовуючи відповідні перевантаження Parallel.ForEach , якщо це потрібно. Детальніше дивіться у розділі Спеціальні учасники на MSDN.

Основна відмінність під час виконання - це те, що другий буде діяти асинхронно. Це можна дублювати за допомогою Parallel.ForEach, виконуючи:

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

Роблячи це, ви все-таки скористаєтеся партнерами, але не блокуйте, поки операція не буде завершена.

Я зробив невеликий експеримент із запуском методу "1 000 000 000 (один мільярд)" разів з "Паралельно.За" і один з "Завданням".

Я виміряв час процесора і виявив, що Паралель більш ефективний. Parallel.For розділяє ваше завдання на невеликі робочі елементи і виконує їх на всіх ядрах паралельно оптимально. Під час створення безлічі об'єктів завдань (FYI TPL буде використовувати внутрішнє об'єднання потоків) переміщуватиме кожне виконання кожної задачі, створюючи більше напруги в полі, що видно з експерименту нижче.

Я також створив невелике відео, в якому пояснюється базовий TPL, а також продемонстровано, як Parallel.For ефективніше використовує ваше ядро http://www.youtube.com/watch?v=No7QqSc5cl8 порівняно зі звичайними завданнями та потоками.

Експеримент 1

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

Експеримент 2

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

Parallel.ForEach буде оптимізувати (може навіть не запускати нові потоки) та блокувати, поки цикл не буде закінчений, і Task.Factory явно створить новий екземпляр завдання для кожного елемента та повернеться до їх закінчення (асинхронні завдання). Parallel.Foreach набагато ефективніший.

На мій погляд, найбільш реалістичний сценарій - це коли завдання мають завершити важку операцію. Підхід Шивпрасада більше зосереджений на створенні об'єктів / розподілі пам'яті, ніж на самих обчисленнях. Я зробив дослідження, назвавши наступний метод:

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

Виконання цього методу займає близько 0,5 сек.

Я називав це 200 разів за допомогою паралелі:

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

Тоді я називав це 200 разів старомодно:

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

Перша справа завершена в 26656 мс, друга в 24478 мс. Я повторював це багато разів. Кожен раз, коли другий підхід стає граничним швидше.