Multi-tasking / multi-threaded applications have always been a bit of a nightmare to create. Different operating systems and sometimes even different compilers and class libraries tends to have their own implementations. Fortunately the .NET / C# implementation of threading is extremely straightforward and makes it simple to create a multi threaded application. In this article we look at building some very simple threaded applications. We go into how to create them, synchronize them and how we can ensure that things such as shared variables are properly protected.

But what are threads anyway? Threading provides the ability for a program to split itself into smaller segments. For example, one thread takes care of the user interface while another task re-calculates data in the background. Because each thread has access to all the variables and memory of the running program there is a need to ensure that they play together nicely. This is solved by adding inter thread communication and synchronization.

To create a new thread, we need to include System.Threading which provides the Thread class. From there on creating a new thread involves only a few steps:

1. Create a new instance of Thread [new Thread()]
2. Pass the code starting point point of the thread in its creation [myThread = new Thread( new ThreadStart( myObj.EntryPoint ) )]
3. Start the Thread [myThread.Start()]

The ThreadStart object mentioned in the Thread constructor is actually a delegate. It defines the format that the entry point function should follow : a function returning “void” that takes no parameters. (Alternatively there is also ParameterizedThreadStart which allows you pass a parameter).

C# makes it possible to name every Thread Object and we use this to give a name to each of the Threads we create.

Each thread is then started and asked to print its name. In total there will be three messages printed: by the main thread and the two threads we create in the example. Also notice that Thread.CurrentThread provides a reference to the currently executing thread.

using System;
using System.Threading;

namespace TheadingDemo1
{

    class ThreadExample
    {

        static void ShowThreadName()
        {
            Console.WriteLine("Current Thread: {0}",Thread.CurrentThread.Name);
        }

        public void ThreadStartPoint()
        {
            ShowThreadName();
        }

        public static void Main()
        {
            // As we enter the program with this thread -- lets call it "main"
            Thread.CurrentThread.Name = "Main";

            // Create two new instances of the current class
            ThreadExample instance1 = new ThreadExample();
            ThreadExample instance2 = new ThreadExample();

            // We need to setup their starting points, which is the same for both
            Thread thread1 = new Thread( new ThreadStart( instance1.ThreadStartPoint ));
            Thread thread2 = new Thread( new ThreadStart( instance2.ThreadStartPoint ));

            // Name each thread
            thread1.Name = "Instance1";
            thread2.Name = "Instance2";

            // Start both threads
            thread1.Start();
            thread2.Start();

            // Display the name of the current (main) thread
            ShowThreadName();           

            Console.WriteLine("Ending Main Tread");
        }

    }

}

The above example will print something similar to the following:

Current Thread: Main
Current Thread: Instance2
Ending Main Tread
Current Thread: Instance1

Note that in this case Instance1 kept on running although the program had already ended. That is because C# makes a distinction between two different kinds of tasks: background tasks and foreground tasks. Foreground threads (the default) will keep the main thread from ending as long as there is still at least one other thread active. Background tasks die when the programs main thread ends.

To see this effect , modify the above code by adding below line 35:

thread1.IsBackground = true;
thread2.IsBackground = true;

Many hands make light work

In the above example we needed to create every task separately, but that becomes tedious if we need to create many. Using the ThreadPool class we only have to queue the actual work, which it will then allocate this to available tasks as required.

A simple example: we have a busy web server and as requests come in we need to serve them. But each request will probably take some time to complete as each thread will need to wait for disk IO and calculations to complete. The ThreadPool class will find an idle task for each new request and if it runs out of idle tasks the ThreadPool will simply create more threads.

Broken down in steps:

1. We create 1000 instances of WebRequest
2. Each is passed to the ReceiveRequest method
3. The main thread starts waiting until everything has completed
4. ReceiveRequest uses ThreadPool.QueueUserWorkItem to queue each request
5. ThreadPool goes over each queue item, allocates it to a task which then calls “HandleRequest” for each
6. The main thread is woken up

We do some more things to smooth communication but first have a look at the code example:

namespace TheadingPool1
{
    // WebRequest
    //
    // This is a simple class that pretends to be a request received from the internet
    // Here it only need to carry a unique number so that we can identify it.

    class WebRequest
    {
        public int id;
        public WebRequest(int id)
        {
            this.id = id;
        }
    }

    // WebServer
    //
    // Our little webserver "receives" requests from the internet, and then queues them
    // The ThreadPool mechanism will allocate a new thread to

    class WebServer
    {
        public int QueueLength;
        ManualResetEvent WaitEvent;
        bool       WaitForComplete;

        public WebServer()
        {
            this.QueueLength = 0;
            this.WaitForComplete = false;
        }

        public void WaitForCompleted()
        {
            // We lock the class to ensure that nobody modifies the QueueLength
            // while we are inspecting it.
            lock(this)
            {
                if (this.QueueLength==0) return;
                WaitEvent = new ManualResetEvent(false);
                WaitForComplete = true;
            }
            // Outside the lock block as we need to free the lock!
            WaitEvent.WaitOne();
        }

        // ReceiveRequest
        //
        // Our webserver has received a request, we use the ThreadPool.QueueWorkItem
        // to find / create a thread that will handle this request.
        //
        // Actual handling of the request is done by the "HandleRequest" function

        public void ReceiveRequest(WebRequest req)
        {
            // This is very simple, there is no need to define the thread pool.
            // We just add work
            ThreadPool.QueueUserWorkItem(new WaitCallback(HandleRequest), req);
            this.QueueLength++;
        }

        public void HandleRequest(Object obj)
        {
            // Notes:
            //
            // 1. Thread.CurrentThread.GetHasCode provides a unique identifies for each thread
            // 2. We need to cast the generic object parameter to our web request

            Console.WriteLine("Thread {0} handles request {1}",
                              Thread.CurrentThread.GetHashCode(),
                              ((WebRequest) obj).id);

            // 3. We add sleep to simulate a task taking some time, otherwise its likely that
            //    a single task is able to handle all our requests in order.

            Thread.Sleep(100);

            // 4. Finished, we reduce one item from the queue. If the queue is empty we need
            //    to free the main program

            lock(this)
            {
                this.QueueLength--;
                if (this.QueueLength == 0 && this.WaitForComplete)
                {
                    this.WaitEvent.Set();
                }
            }
        }

        public static void Main()
        {
            WebServer server = new WebServer();

            // "Receive" 1000 requests from the internet and queue them
            for (int Lp = 0; Lp < 1000; Lp ++)
                server.ReceiveRequest( new WebRequest( Lp ));

            // We wait until the queue has emptied
            server.WaitForCompleted();

            Console.WriteLine("Main Thread has completed");
        }
    }
}

So how do we know if the work has been completed?

The Webserver class keeps track of the number of outstanding tasks and as soon as this reaches zero the task completing the last work item frees the main task from its wait.

This is done by using a ManualResetEvent.

Any task which calls WaitOne() on a ManualResetEvent will be suspended until another task frees it by calling Set(). It is possible for more tasks to wait for the same ManualResetEvent, but in our example only the main task needs to wait.

When our HandleRequest method discovers that it has handled the last outstanding request it calls Set() freeing the main task to end the program.

We need to avoid interruption

As multiple tasks are executing the code at the same time several critical sections might be updated by more than one task at the same time.

In our example the critical code is the code which maintains the QueueLength variable. Every time a task is completed it reduces QueueLength by one, and every time a task is added QueueLength is increased. But what happens if a task reduces the QueueLength while another one is checking if its zero?

There are several things that could go unexpectedly wrong, which is something called a “race condition”.

We would like to ensure that these statements are executed in order and without interruption — as an essentially atomic operation.

C# allows you to synchronize tasks by exclusively locking a code segment with the lock() statement. Only one task can enter this segment of the code. All others tasks reaching it will be suspended until the first task has completed it.

lock(this)
{
   // The code between these brackets can only be entered by one task modifying this instance
   // of the class
}

In the example above we have protected each critical section that modifies QueueLength by placing it in an exclusive block.

This is the ABC of building a threaded application in C#. In another article I hope to go further into the details of inter thread and inter process communication.

Image credit: chefranden

This is a post from Martijn's C# Coding Blog.