CODEWITHSUNDEEP
c#parallel-processingtask-parallel-library
Dhawal
Dhawal

Reputation: 1310

AsParallel.ForAll vs Parallel.ForEach

Is there any difference between the below code snippets. If so, what?

myList.AsParallel().ForAll(i => { /*DO SOMETHING*/ });

and

Parallel.ForEach(mylist, i => { /*DO SOMETHING*/ });

Will the main thread wait for all the child threads to complete? In a MVC application, if I'm doing parallel processing in my controller action, what happens to the child threads after the main thread completes. Will they be aborted or will they be completed even after the main thread is completed?

Upvotes: 48

Views: 41102

Answers (4)

Dmitriy Bobrovskiy
Dmitriy Bobrovskiy

Reputation: 163

As written in Concurrency in C# Cookbook:

One difference between Parallel and PLINQ is that PLINQ assumes it can use all of the cores on the computer, while Parallel will dynamically react to changing CPU conditions.

Upvotes: 5

dsum
dsum

Reputation: 1493

Here is an explanation in MSDN:

https://learn.microsoft.com/en-us/dotnet/standard/parallel-programming/potential-pitfalls-with-plinq#prefer-forall-to-foreach-when-it-is-possible

Based on what I read, use Parallel.ForEach() if you want to ensure the list are access sequentially while using AsParallel.ForAll() does not guarantee the items in the list are accessed in order.

For MVC, all thread are request-based. The caller thread (main) is blocked until the Parallel() call is completed, that means all child threads should have completed as well.

If the caller thread is aborting, here is an explain:

http://www.albahari.com/threading/part5.aspx

PLINQ doesn't preemptively abort threads, because of the danger of doing so. Instead, upon cancellation it waits for each worker thread to finish with its current element before ending the query. This means that any external methods that the query calls will run to completion.

Upvotes: 4

thewpfguy
thewpfguy

Reputation: 824

You have the option to order the elements with AsParallel().AsOrdered(). Ordering in Parallel.ForEach is not out of box, we need do it.

Upvotes: -1

svick
svick

Reputation: 245036

Parallel.ForEach() is intended exactly for this kind of code.

On the other hand, ForAll() is intended to be used at the end of a (possibly complex) PLINQ query.

Because of that, I think Parallel.ForEach() is the better choice here.

In both cases, the current thread will be used to perform the computations (along with some threads from the thread pool) and the method will return only after all processing has been completed.

Upvotes: 25

Related Questions