Parallel.ForEach vs Task.Factory.StartNew

Sự khác biệt giữa các đoạn mã dưới đây là gì? Cả hai sẽ không sử dụng chủ đề threadpool?

Chẳng hạn, nếu tôi muốn gọi một hàm cho mỗi mục trong một bộ sưu tập,

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

vs

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

Đầu tiên là một lựa chọn tốt hơn nhiều.

Parallel.ForEach, trong nội bộ, sử dụng a Partitioner<T>để phân phối bộ sưu tập của bạn vào các mục công việc. Nó sẽ không thực hiện một nhiệm vụ cho mỗi mục, mà thay vào đó là đợt này để giảm chi phí liên quan.

Tùy chọn thứ hai sẽ lên lịch Taskcho mỗi mục trong bộ sưu tập của bạn. Mặc dù các kết quả sẽ (gần như) giống nhau, nhưng điều này sẽ giới thiệu nhiều chi phí hơn mức cần thiết, đặc biệt là đối với các bộ sưu tập lớn và khiến thời gian chạy tổng thể chậm hơn.

FYI - Trình phân vùng được sử dụng có thể được kiểm soát bằng cách sử dụng quá tải thích hợp cho Parallel.ForEach , nếu muốn. Để biết chi tiết, xem Phân vùng tùy chỉnh trên MSDN.

Sự khác biệt chính, tại thời gian chạy, là thứ hai sẽ hoạt động không đồng bộ. Điều này có thể được nhân đôi bằng Parallel.ForEach bằng cách thực hiện:

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

Bằng cách này, bạn vẫn tận dụng các trình phân vùng, nhưng không chặn cho đến khi hoàn thành thao tác.

Tôi đã thực hiện một thử nghiệm nhỏ khi chạy phương thức "1.000.000.000 (một tỷ)" lần với "Parallel.For" và một với các đối tượng "Nhiệm vụ".

Tôi đo thời gian xử lý và thấy Parallel hiệu quả hơn. Parallel.For phân chia nhiệm vụ của bạn thành các mục công việc nhỏ và thực hiện chúng trên tất cả các lõi theo cách tối ưu. Trong khi tạo nhiều đối tượng tác vụ (FYI TPL sẽ sử dụng tổng hợp luồng trong nội bộ) sẽ di chuyển mọi thực thi trên mỗi tác vụ tạo thêm căng thẳng trong hộp hiển nhiên từ thử nghiệm bên dưới.

Tôi cũng đã tạo một video nhỏ giải thích TPL cơ bản và cũng trình bày cách Parallel.For sử dụng lõi của bạn hiệu quả hơn http://www.youtube.com/watch?v=No7QqSc5cl8 so với các tác vụ và chủ đề thông thường.

Thí nghiệm 1

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

Thí nghiệm 2

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

Parallel.ForEach sẽ tối ưu hóa (thậm chí có thể không bắt đầu các luồng mới) và chặn cho đến khi vòng lặp kết thúc và Task.Factory sẽ rõ ràng tạo một thể hiện nhiệm vụ mới cho mỗi mục và trả về trước khi chúng kết thúc (các tác vụ không đồng bộ). Parallel.Foreach hiệu quả hơn nhiều.

Theo quan điểm của tôi, kịch bản thực tế nhất là khi các tác vụ phải hoàn thành một hoạt động nặng. Cách tiếp cận của Shivprasad tập trung nhiều vào việc tạo đối tượng / phân bổ bộ nhớ hơn là vào chính máy tính. Tôi đã thực hiện một nghiên cứu gọi phương pháp sau:

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

Thực hiện phương pháp này mất khoảng 0,5 giây.

Tôi đã gọi nó 200 lần bằng cách sử dụng Parallel:

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

Sau đó, tôi gọi nó 200 lần bằng cách sử dụng kiểu cũ:

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

Trường hợp đầu tiên hoàn thành trong 26656ms, lần thứ hai trong 24478ms. Tôi đã lặp lại nó nhiều lần. Mỗi lần tiếp cận thứ hai là nhanh hơn.