Parallel.ForEach เทียบกับ Task.Fartory.StartNew

ความแตกต่างระหว่างตัวอย่างโค้ดด้านล่างคืออะไร ทั้งสองจะไม่ใช้เธรดพูลหรือไม่

เช่นถ้าฉันต้องการเรียกใช้ฟังก์ชันสำหรับแต่ละรายการในคอลเลกชัน

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

vs

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

แรกคือตัวเลือกที่ดีกว่ามาก

Parallel.ForEach ภายในใช้Partitioner<T>เพื่อแจกจ่ายคอลเลกชันของคุณไปยังรายการงาน มันจะไม่ทำงานหนึ่งรายการต่อหนึ่งรายการ แต่ควรทำแบบนี้เพื่อลดค่าใช้จ่ายที่เกี่ยวข้อง

ตัวเลือกที่สองจะกำหนดตารางเวลาหนึ่งTaskรายการในคอลเลกชันของคุณ ในขณะที่ผลลัพธ์จะเป็น (เกือบ) เหมือนกันสิ่งนี้จะแนะนำค่าใช้จ่ายมากกว่าที่จำเป็นโดยเฉพาะอย่างยิ่งสำหรับคอลเลกชันขนาดใหญ่และทำให้เวลาทำงานโดยรวมจะช้าลง

FYI - The Partitioner ที่ใช้สามารถควบคุมได้โดยใช้overloadsที่เหมาะสมเพื่อ Parallel.ForEachหากต้องการ สำหรับรายละเอียดโปรดดูCustom Partitionersบน MSDN

ความแตกต่างหลัก ณ รันไทม์คือวินาทีจะทำหน้าที่แบบอะซิงโครนัส สามารถทำซ้ำได้โดยใช้ Parallel.ForEach โดยทำ:

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

ด้วยการทำเช่นนี้คุณยังคงได้รับประโยชน์จากพาร์ทิชัน แต่อย่าปิดกั้นจนกว่าการดำเนินการจะเสร็จสมบูรณ์

ฉันทำการทดลองใช้วิธี "1,000,000,000 (หนึ่งพันล้านครั้ง)" ครั้งเล็ก ๆ ด้วย "Parallel.For" และอีกหนึ่งเป็นวัตถุ "Task"

ฉันวัดเวลาโปรเซสเซอร์และพบว่า Parallel มีประสิทธิภาพมากขึ้น 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 มีประสิทธิภาพมากขึ้น

ในมุมมองของฉันสถานการณ์ที่สมจริงที่สุดคือเมื่องานมีการดำเนินการอย่างหนักเพื่อให้เสร็จสมบูรณ์ วิธีการของ Shivprasad มุ่งเน้นไปที่การสร้างวัตถุ / การจัดสรรหน่วยความจำมากกว่าในการคำนวณเอง ฉันทำวิจัยเรียกวิธีต่อไปนี้:

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:

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

กรณีแรกเสร็จสมบูรณ์ใน 26656ms วินาทีใน 24478ms ฉันทำซ้ำหลายครั้ง ทุกครั้งที่วิธีที่สองนั้นรวดเร็วกว่าเล็กน้อย