A Better Approach

One of the great new features of .NET 4 is the parallel task library which easily lets you turn simple for loops and foreach loops into multi-core aware tasks. 

Our Examples:

For the example we are going to simply iterate over a collection of items and perform some hard work inside that collection.  Our hard work could be almost any task but for simplicity we are going to treat the hard work as just iterating over the collection again.

var range = Enumerable.Range(0, 10000).ToList();

Action<int> hardWork = i =>
{
    for (int j = 0; j < range.Count; j++)
    {
    }
};

for(;;)

Lets start off with the simple for loop

private static void ForLoop(IList<int> range, Action<int> work)
{
    var stopwatch = new Stopwatch();

    stopwatch.Start();
    for (int i = 0; i < range.Count; i++)
    {
        work(i);
    }
    stopwatch.Stop();

    Console.WriteLine("Total Elapsed Milliseconds for(;;): {0}", stopwatch.ElapsedMilliseconds);
}

If you run this example you will see the elapsed milliseconds to be around +/- 483.

Now that we have our baseline lets attempt to convert this for loop to use the Parallel.For method.

private static void ParallelFor(List<int> range, Action<int> hardWork)
{
    var stopwatch = new Stopwatch();
    stopwatch.Start();
    Parallel.For(0, range.Count, hardWork);
    stopwatch.Stop();

    Console.WriteLine("Total Elapsed Milliseconds  Parallel.For(): {0}", stopwatch.ElapsedMilliseconds);
}

This signature for Parallel.For is quite simple, our from value, our to value, and what action we wish to take during each iteration.  If we run this example again we see that the total elapsed time for Parallel.For is 139 milliseconds which is approximately 350 milliseconds faster!  What ends up happening here is that Parallel.For will spin up additional threads to iterate over your collection and perform the action thus speeding up your processing time.

foreach()

Using our same starting point lets convert our for loop over to a foreach loop.

private static void ForEach(IEnumerable<int> range, Action<int> work)
{
    var stopwatch = new Stopwatch();

    stopwatch.Start();
    foreach (var i in range)
    {
        work(i);
    }
    stopwatch.Stop();

    Console.WriteLine("Total Elapsed Milliseconds foreach(): {0}", stopwatch.ElapsedMilliseconds);
}

Running this example gives you around the same millisecond duration as the for loop. 

Now if we want to convert this to a Parallel.ForEach you simply do the following:

private static void ParallelForEach(IEnumerable<int> range, Action<int> hardWork)
{
    var stopwatch = new Stopwatch();
    stopwatch.Start();
    Parallel.ForEach(range, hardWork);
    stopwatch.Stop();

    Console.WriteLine("Total Elapsed Milliseconds  Parallel.ForEach(): {0}", stopwatch.ElapsedMilliseconds);
}

This signature for the Parallel.ForEach is the collection you want to iteration over and the action you wish to perform in this case it is Action<int>.  Our elapsed time is almost identical for our Parallel.For loop example above.

Some Gotchas

Now seeing this you might ask Parallel.For[Each] is the new hotness and we should use it EVERYWHERE!  However this is not exactly the case. 

Consider the following:

public static void Run()
{
    var range = Enumerable.Range(0, 1000).ToList();

    Action<int> hardWork = i =>
                          {
                              for (int j = 0; j < 10; j++)
                              {
                              }
                          };

    ForLoop(range, hardWork);
    ParallelFor(range, hardWork);
    //ForEach(range, hardWork);
   // ParallelForEach(range, hardWork);
}

private static void ForLoop(IList<int> range, Action<int> work)
{
    var stopwatch = new Stopwatch();

    stopwatch.Start();
    for (int i = 0; i < range.Count; i++)
    {
        work(i);
    }
    stopwatch.Stop();

    Console.WriteLine("Total Elapsed Ticks for(;;): {0}", stopwatch.ElapsedTicks);
}

private static void ParallelFor(List<int> range, Action<int> hardWork)
{
    var stopwatch = new Stopwatch();
    stopwatch.Start();
    Parallel.For(0, range.Count, hardWork);
    stopwatch.Stop();

    Console.WriteLine("Total Elapsed Ticks  Parallel.For(): {0}", stopwatch.ElapsedTicks);
}

Now all we did here was decrease the number of times we iterate over the collection and make the hard work less “hard”.  We also changed the stopwatch to give us elapsed ticks instead of milliseconds for a more precise measurement.

Total Elapsed Ticks for(;;): 370 
Total Elapsed Ticks  Parallel.For(): 2352

How is this possible?  More threads, multi-core, parallel, it should be faster always!  but this is not always the case as there is additional overhead on building up and starting these threads.  If the work is known to be small writing a simple for loop/foreach loop most of the time will be faster.

Thread Local

Another option for the Parallel library is initializing a variable for each thread iterating over the collection.  This could become handy if you are iterating over a huge collection and want to create an instance to some service for each thread to use instead of using one global instance.

Example.

private class MyService
{
    public MyService()
    {
        Console.WriteLine("My Service Created");
    }

    public void Close()
    {
        Console.WriteLine("My Service Closed");
    }
}

This is a sample class that simply outputs when the service is created and when it is closed.  Now to use this service as a thread local in our Parallel.ForEach()

private static void ParallelForEachThreadLocal(List<int> range, Action<int> hardWork)
{
    var stopwatch = new Stopwatch();

    stopwatch.Start();
    Parallel.ForEach(range, () => new MyService(), (i, loopState, myService) =>
                                                       {
                                                           hardWork(i);
                                                           return myService;
                                                       }, service => service.Close());
    stopwatch.Stop();

    Console.WriteLine("Total Elapsed Milliseconds foreach(): {0}", stopwatch.ElapsedMilliseconds);
}

Our signature for using thread local is a little bit different. 

1. We have our collection we want to iterate over.
2. Our thread local, in this case we want a new instance of MyService per thread.
3. Next we have our action that will be ran over each iteration,  This signature now is a bit different, first we have our int, next the loopState, and our newly introduced thread local variable of myService, this function also has to return our thread local so it can be used for the next iteration.
4. Our final action then is the finally action we wish to perform on our thread local instance.  In this case we want to simply call Close()

If you run our example you can easily see our output and how the threads insatiate a new instance of MyService and then close it down when the iteration is finished.

My Service Created
My Service Created
My Service Created
My Service Created
My Service Created
My Service Closed
My Service Closed
My Service Closed
My Service Closed
My Service Closed
Total Elapsed Milliseconds : 122

Well that just touches the surface of the Parallel library in .NET 4.0 if you wish to learn more check out msdn at the Task Parallel Library.