Threads Made Easy in Visual Basic

by Paul Kimmel

Learn to use the basic parallel operations--multithreading--incorporated into .NET framework 4.0.


Multithreading can be challenging. Using a lot of threads can make an application much more difficult to debug and buggier. The Parallel FX Library was created to make your life a little easier. Now the features that were in a separate download are part of the .NET Framework 4.0, and they can add a little zip to your application with a lot fewer headaches.

Everyone wants substantial performance increases and when needed programmers often turn to multithreading. However, if you follow the basic mathematics of Amdahl's law and Gustafson's law then you know that just chunking the work by adding threads does not produce linear increases in performance. Use threads sparingly but use them more safely with the features presented in this article.

Preparing Your Microsoft Visual Studio 2010 Environment

To try the samples create a new Console application in Microsoft Visual Studio 2010. To use the Parallel features make sure your project is using the .NET Framework 4.0. To select the target framework click the Project|project_name Properties menu item, switch to the Compile tab and click the Advanced Compile Options. At the bottom of that dialog is the Target framework select-see Figure 1. Change the target framework to the .NET Framework 4 Client Profile.

Figure 1 - Make sure the target framework is .NET 4.0

The Parallel extensions used for the demo are in System.Threading.Tasks, so add a reference to this namespace in your project using an Imports statement.

Using Parallel.ForEach

Parallel.ForEach has several overloaded versions that accept an IEnumerable(Of T) collection and an Action generic delegate. The method executes a for each operation and iterations may be run in parallel. The following fragment uses the Shared Enumerable.Range method and generates a range of numbers from 1 to 1000. The LINQ query selects just the even numbers and the Paralle.ForEach method uses a Lambda expression to write the contents to the console in parallel. Figure 2 shows all of thread spun up for this statement.

  Dim data = Enumerable.Range(1, 1000)

' Implicit line continuation - No line continuation. Yeah!
Dim evens = From e In data
     Where e Mod 2 = 0
     Select e

Parallel.ForEach(evens, Sub(i) Console.Write(i.ToString() + ", "))

Figure 2: Threads galore for Parallel.ForEach

It is worth noting that the order of the data is not necessarily preserved, which is a consideration if you are using Parallel.ForEach.

Using the AsParallel Extension Method for IEnumerable(OF T)

The next example uses IEnumerable(Of T).AsParallel to execute the LINQ query in parallel. Again in this instance the order of the items will not be preserved.

  Dim data = Enumerable.Range(1, 1000)

' similar results to sending to console in parallel
Dim evens2 = From e In data.AsParallel
    Where e Mod 2 = 0
    Select e

Array.ForEach(Of Integer)(evens2.ToArray(), Sub(i) Console.WriteLine(i))

You can click on Debug|Windows|Threads to see the threads created or Debug|Windows|Parallel Tasks to view the status of the parallel tasks-see Figure 3.

[Tip: A nice feature of Microsoft Visual Studio 2010 is when you float and then dock a frame in VS2010 the docked window returns automatically to its default dock position; this is a lot nicer than trying to drag it back to its docked position.]

Figure 3: View the status of parallel tasks by selecting Debug|Windows|Parallel Tasks while debugging in Visual Studio 2010

Maintaining Order with AsParallel

If you want to maintain the order of items in a parallel LINQ query then call IEnumerable(Of T).AsParallel.AsOrdered on the data source. To quote the help documentation "A natural tension exists between performance and preserving order in parallel processing". This tension is probably manifested as slightly poorer performance in the parallel processing, but if you need to preserve the original order then use AsOrdered as demonstrated in the follow code fragment.

  Dim data = Enumerable.Range(1, 1000)

' Parallel while maintaining order
Dim evensOrdered = From e In data.AsParallel.AsOrdered
       Where e Mod 2 = 0
       Select e

Array.ForEach(Of Integer)(evensOrdered.ToArray(), Sub(i) Console.WriteLine(i))

On a side note, notice that .NET 4.0 supports Lambda expressions that are subroutines. That is, you can use Sub or Function to write your Lambda expressions. Function only expressions where limiting in earlier versions of .NET. Function-only expressions meant you had to contrive a return value whether you needed on or not. (Good job Microsoft.)

Calling Parallel.Invoke

Parallel.Invoke accepts a ParamArray-an arbitrary number-of Action delegates and performs these tasks in Parallel. The following fragment demonstrates how to write several strings to the console in parallel. (Of course, you can actually invoke methods that perform real work, but you get the idea.)

   Dim master() As String = New String() {
  "Master! Master! I have these two dogs the past that limits ",
   "me and the future that inspires me fighting inside of me. Which one will win? ",
    "Master replies: the one you feed the most."}

 Parallel.Invoke(Sub() Console.WriteLine(master(0)), Sub() Console.WriteLine(master(1)),
                        Sub() Console.WriteLine(master(2)))

Of course, you can still use background workers, monitors, locks, or the ThreadPool if you like, but for simplicity see if you can't get the job done using the new, managed parallel features of .NET 4.0.


The only constant is change. Upgrade to Microsoft Visual Studio 2010. Just getting rid of line continuation is enough for me, but upgrade so you can use LINQ, Parallel constructs, the new and improved Entity Framework features and all of the cool features in VS2010. And thank you for reading all of these years.

This article was originally published on Tuesday Mar 16th 2010
Mobile Site | Full Site