Parallel.ForEach ve Task.Factory.StartYeni

Aşağıdaki kod snippet'leri arasındaki fark nedir? Her ikisi de threadpool dişlerini kullanmayacak mı?

Örneğin, bir koleksiyondaki her öğe için bir işlev çağırmak istersem,

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

vs

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

Birincisi çok daha iyi bir seçenektir.

Paralel.ForEach, dahili olarak, Partitioner<T>koleksiyonunuzu iş öğelerine dağıtmak için a kullanır . Öğe başına bir görev yapmaz, bunun yerine ilgili ek yükü azaltmak için bunu toplu olarak işler.

İkinci seçenek, Taskkoleksiyonunuzdaki her öğe için bir tane zamanlayacaktır . Sonuçlar (neredeyse) aynı olsa da, bu özellikle büyük koleksiyonlar için gerekenden çok daha fazla yük getirecek ve genel çalışma sürelerinin daha yavaş olmasına neden olacaktır.

FYI - Kullanılan Partitioner , istenirse Parallel.ForEach için uygun aşırı yükler kullanılarak kontrol edilebilir . Ayrıntılar için bkz . MSDN'deki Özel Bölümleyiciler.

Çalışma zamanında temel fark, ikincisinin eşzamansız davranmasıdır. Bu, Parallel.ForEach kullanılarak şu şekilde çoğaltılabilir:

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

Bunu yaparak, bölücülerden yararlanmaya devam edersiniz, ancak işlem tamamlanana kadar engellemeyin.

"Parallel.For" ve "Task" nesneleri ile bir "1.000.000.000 (bir milyar)" yöntemi çalıştırmak için küçük bir deneme yaptım.

İşlemci süresini ölçtüm ve Paralel'i daha verimli buldum. Görevinizi küçük iş öğelerine ayırır ve bunları tüm çekirdeklerde paralel olarak en uygun şekilde yürütür. Çok sayıda görev nesnesi oluştururken (FYI TPL, iş parçacığı havuzunu dahili olarak kullanacaktır), her deneyde her bir yürütmeyi, aşağıdaki deneyden belirgin olan kutuda daha fazla stres yaratarak hareket ettirecektir.

Ayrıca temel TPL açıklar ve aynı zamanda Parallel.For daha verimli iç kısmı kullanır nasıl gösterdi küçük bir video oluşturduk http://www.youtube.com/watch?v=No7QqSc5cl8 normal görevler ve iş parçacığı ile karşılaştırıldığında.

Deney 1

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

Deney 2

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

Parallel.ForEach, döngü tamamlanıncaya kadar optimizasyon yapar (hatta yeni iş parçacıkları başlatmayabilir) ve engeller ve Task.Factory her öğe için açıkça yeni bir görev örneği oluşturur ve tamamlanmadan önce geri döner (eşzamansız görevler). Paralel. Foreach çok daha verimlidir.

Bana göre en gerçekçi senaryo, görevlerin tamamlanması gereken ağır bir işlem olduğunda. Shivprasad'ın yaklaşımı, bilgi işlemden çok nesne oluşturma / bellek tahsisine odaklanır. Aşağıdaki yöntemi çağıran bir araştırma yaptım:

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

Bu yöntemin yürütülmesi yaklaşık 0.5 saniye sürer.

Paralel kullanarak 200 kez aradım:

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

Sonra eski moda yolu kullanarak 200 kez aradım:

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

İlk vaka 26656ms, ikincisi 24478ms'de tamamlandı. Birçok kez tekrarladım. Her seferinde ikinci yaklaşım marjinal olarak daha hızlıdır.