Chapter 1. Threading Basics

In this chapter, we will cover the basic tasks for working with threads in C#. You will learn about:

Creating a thread in C#
Pausing a thread
Making a thread wait
Aborting a thread
Determining thread state
Thread priority
Foreground and background threads
Passing parameters to a thread
Locking with a C# lock keyword
Locking with a Monitor construct
Handling exceptions

Introduction

At some point of time in the past, the common computer had only one computing unit and could not execute several computing tasks simultaneously. However, operating systems could already work with multiple programs simultaneously, implementing the concept of multitasking. To prevent the possibility of one program taking control of the CPU, forever causing other applications and the operating system itself to hang, the operating systems had to split a physical computing unit across a few virtualized processors in some way and give a certain amount of computing power to each executing program. Moreover, an operating system must always have priority access to the CPU and should be able to prioritize CPU access to different programs. A thread is an implementation of this concept. It could be considered a virtual processor given to the one specific program that runs it independently.

Note

Remember that a thread consumes a significant amount of operating system resources. Trying to share one physical processor across many threads will lead to a situation where an operating system is busy just managing threads instead of running programs.

Therefore, while it was possible to enhance computer processors, making them execute more and more commands per second, working with threads was usually an operating system task. There was no sense in trying to compute some tasks in parallel on a single-core CPU because it would take more time than running those computations sequentially. However, when processors started to have more computing cores, older programs could not take advantage of this because they just used one processor core.

To use a modern processor's computing power effectively, it is very important to be able to compose a program in a way that it can use more than one computing core, which leads to organizing it as several threads communicating and synchronizing with each other.

The recipes in this chapter will focus on performing some very basic operations with threads in the C# language. We will cover a thread's lifecycle, which includes creating, suspending, making a thread wait, and aborting a thread, and then we will go through basic synchronization techniques.

Creating a thread in C#

Throughout the following recipes, we will use Visual Studio 2012 as the main tool to write multithreaded programs in C#. This recipe will show you how to create a new C# program and use threads in it.

Note

There are free Visual Studio 2012 Express editions, which can be downloaded from the Microsoft website. We will need Visual Studio 2012 Express for Windows Desktop for most of the examples and Visual Studio 2012 Express for Windows 8 for Windows 8-specific recipes.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe1.

Tip

Downloading the example code

You can download the example code files for all Packt books you have purchased through your account at http://www.packtpub.com. If you purchased this book elsewhere, you can visit http://www.packtpub.com/support and register to have the files e-mailed directly to you.

How to do it...

To understand how to create a new C# program and use threads in it, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
Make sure that the project uses .NET Framework 4.0 or higher version.
In the Program.cs file add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void PrintNumbers()
{
  Console.WriteLine("Starting...");
  for (int i = 1; i < 10; i++)
  {
    Console.WriteLine(i);
  }
}

Add the following code snippet inside the Main method:

Thread t = new Thread(PrintNumbers);
t.Start();
PrintNumbers();

Run the program. The output will be something like:

How it works...

In steps 1 and 2 we created a simple console application in C# using .Net Framework version 4.0. Then in step 3 we included the namespace System.Threading, which contains all the types needed for the program.

Note

An instance of a program is being executed can be referred to as a process. A process consists of one or more threads. This means that when we run a program, we always have one main thread that executes the program code.

In step 4 we defined the method PrintNumbers, which will be used in both the main and newly created threads. Then in step 5, we created a thread that runs PrintNumbers. When we construct a thread, an instance of the ThreadStart or ParameterizedThreadStart delegate is passed to the constructor. The C# compiler is creating this object behind the scenes when we just type the name of the method we want to run in a different thread. Then we start a thread and run PrintNumbers in the usual manner on the main thread.

As a result, there will be two ranges of numbers from 1 to 10 randomly crossing each other. This illustrates that the PrintNumbers method runs simultaneously on the main thread and on the other thread.

Pausing a thread

This recipe will show you how to make a thread wait for some time without wasting operating system resources.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe2.

How to do it...

To understand how to make a thread wait without wasting operating system resource, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void PrintNumbers()
{
  Console.WriteLine("Starting...");
  for (int i = 1; i < 10; i++)
  {
    Console.WriteLine(i);
  }
}
static void PrintNumbersWithDelay()
{
  Console.WriteLine("Starting...");
  for (int i = 1; i < 10; i++)
  {
    Thread.Sleep(TimeSpan.FromSeconds(2));
    Console.WriteLine(i);
  }
}

Add the following code snippet inside the Main method:

Thread t = new Thread(PrintNumbersWithDelay);
t.Start();
PrintNumbers();

Run the program.

How it works...

When the program is run, it creates a thread that will execute a code in the PrintNumbersWithDelay method. Immediately after that, it runs the PrintNumbers method. The key feature here is adding the Thread.Sleep method call to a PrintNumbersWithDelay method. It causes a thread executing this code to wait a specified amount of time (two seconds in our case) before printing each number. While a thread is sleeping, it uses as little CPU time as possible. As a result, we will see that the code in the PrintNumbers method that usually runs later will be executed before the code in the PrintNumbersWithDelay method in a separate thread.

Making a thread wait

This recipe will show you how a program can wait for some computation in another thread to complete to use its result later in the code. It is not enough to use Thread.Sleep because we don't know the exact time the computation will take.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe3.

How to do it...

To understand how a program can wait for some computation in another thread to complete to use its result later, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file, add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void PrintNumbersWithDelay()
{
  Console.WriteLine("Starting...");
  for (int i = 1; i < 10; i++)
  {
    Thread.Sleep(TimeSpan.FromSeconds(2));
    Console.WriteLine(i);
  }
}

Add the following code snippet inside the Main method:

Console.WriteLine("Starting...");
Thread t = new Thread(PrintNumbersWithDelay);
t.Start();
t.Join();
Console.WriteLine("Thread completed");

Run the program.

How it works...

When the program is run, it runs a long-running thread that prints out numbers and waits two seconds before printing each number. But in the main program, we called the t.Join method, which allows us to wait for thread t to complete. When it is complete, the main program continues to run. With the help of this technique, it is possible to synchronize execution steps between two threads. The first one waits until another one is complete and then continues to work. While the first thread is waiting, it is in a blocked state (as it is in the previous recipe when you call Thread.Sleep).

Aborting a thread

In this recipe, we will describe how to abort another thread's execution.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe4.

How to do it...

To understand how to abort another thread's execution, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file, add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void PrintNumbersWithDelay()
{
  Console.WriteLine("Starting...");
  for (int i = 1; i < 10; i++)
  {
    Thread.Sleep(TimeSpan.FromSeconds(2));
    Console.WriteLine(i);
  }
}

Add the following code snippet inside the Main method:

Console.WriteLine("Starting program...");
Thread t = new Thread(PrintNumbersWithDelay);
t.Start();
Thread.Sleep(TimeSpan.FromSeconds(6));
t.Abort();
Console.WriteLine("A thread has been aborted");
Thread t = new Thread(PrintNumbers);
t.Start();
PrintNumbers();

Run the program.

How it works...

When the main program and a separate number-printing thread run, we wait for 6 seconds and then call a t.Abort method on a thread. This injects a ThreadAbortException method into a thread causing it to terminate. It is very dangerous, generally because this exception can happen at any point and may totally destroy the application. In addition, it is not always possible to terminate a thread with this technique. The target thread may refuse to abort by handling this exception and calling the Thread.ResetAbort method. Thus, it is not recommended that you use the Abort method to close a thread. There are different methods that are preferred, such as providing a CancellationToken method to cancel a thread execution. This approach will be described in Chapter 3, Using a Thread Pool.

Determining a thread state

This recipe will describe possible states a thread could have. It is useful to get information about whether a thread is started yet or whether it is in a blocked state. Please note that because a thread runs independently, its state could be changed at any time.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe5.

How to do it...

To understand how to determine a thread state and acquire useful information about it, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file, add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void DoNothing()
{
  Thread.Sleep(TimeSpan.FromSeconds(2));
}

static void PrintNumbersWithStatus()
{
  Console.WriteLine("Starting...");
  Console.WriteLine(Thread.CurrentThread
  .ThreadState.ToString());
  for (int i = 1; i < 10; i++)
  {
    Thread.Sleep(TimeSpan.FromSeconds(2));
    Console.WriteLine(i);
  }
}

Add the following code snippet inside the Main method:

Console.WriteLine("Starting program...");
Thread t = new Thread(PrintNumbersWithStatus);
Thread t2 = new Thread(DoNothing);
Console.WriteLine(t.ThreadState.ToString());
t2.Start();
t.Start();
for (int i = 1; i < 30; i++)
{
  Console.WriteLine(t.ThreadState.ToString());
}
Thread.Sleep(TimeSpan.FromSeconds(6));
t.Abort();
Console.WriteLine("A thread has been aborted");
Console.WriteLine(t.ThreadState.ToString());
Console.WriteLine(t2.ThreadState.ToString());

Run the program.

How it works...

When the main program starts it defines two different threads; one of them will be aborted and the other runs successfully. The thread state is located in the ThreadState property of a Thread object, which is a C# enumeration. At first the thread has a ThreadState.Unstarted state. Then we run it and assume that, for the duration of 30 iterations of a cycle, the thread will change its state from ThreadState.Running to ThreadState.WaitSleepJoin.

Tip

Please note that the current Thread object is always accessible through the Thread.CurrentThread static property.

If it does not happen, just increase the number of iterations. Then we abort the first thread and see that now it has a ThreadState.Aborted state. It is also possible that the program will print out the ThreadState.AbortRequested state. This illustrates very well the complexity of synchronizing two threads. Please keep in mind that you should not use thread abortion in your programs. I've covered it here only to show the corresponding thread state.

Finally, we can see that our second thread t2 completed successfully and now has a ThreadState.Stopped state. There are several other states, but they are partly deprecated and partly not as useful as those we examined.

Thread priority

This recipe will describe the different possible options for thread priority. Setting a thread priority determines how much CPU time a thread will be given.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe6.

How to do it...

To understand the workings of thread priority, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.

In the Program.cs file, add the following using directives:

using System;
using System.Diagnostics;
using System.Threading;

Add the following code snippet below the Main method:

static void RunThreads()
{
  var sample = new ThreadSample();

  var threadOne = new Thread(sample.CountNumbers);
  threadOne.Name = "ThreadOne";
  var threadTwo = new Thread(sample.CountNumbers);
  threadTwo.Name = "ThreadTwo";

  threadOne.Priority = ThreadPriority.Highest;
  threadTwo.Priority = ThreadPriority.Lowest;
  threadOne.Start();
  threadTwo.Start();

  Thread.Sleep(TimeSpan.FromSeconds(2));
  sample.Stop();
}
class ThreadSample
{
  private bool _isStopped = false;
  public void Stop()
  {
    _isStopped = true;
  }

  public void CountNumbers()
  {
    long counter = 0;

    while (!_isStopped)
    {
      counter++;
    }

    Console.WriteLine("{0} with {1,11} priority " +"has a count = {2,13}", Thread.CurrentThread.Name, Thread.CurrentThread.Priority,counter.ToString("N0"));
  }
}

Add the following code snippet inside the Main method:

Console.WriteLine("Current thread priority: {0}", Thread.CurrentThread.Priority);
Console.WriteLine("Running on all cores available");
RunThreads();
Thread.Sleep(TimeSpan.FromSeconds(2));
Console.WriteLine("Running on a single core");
Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
RunThreads();

Run the program.

How it works...

When the main program starts, it defines two different threads. The first one, ThreadPriority.Highest, will have the highest thread priority, while the second one, that is ThreadPriority.Lowest, will have the lowest. We print out the main thread priority value and then start these two threads on all available cores. If we have more than one computing core, we should get an initial result within two seconds. The highest priority thread should calculate more iterations usually, but both values should be close. However, if there are any other programs running that load all the CPU cores, the situation could be quite different.

To simulate this situation, we set up the ProcessorAffinity option, instructing the operating system to run all our threads on a single CPU core (number one). Now the results should be very different and the calculations will take more than 2 seconds. This happens because the CPU core will run mostly the high-priority thread, giving the rest of the threads very little time.

Please note that this is an illustration of how an operating system works with thread prioritization. Usually, you should not write programs relying on this behavior.

Foreground and background threads

This recipe will describe what foreground and background threads are and how setting this option affects the program's behavior.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe7.

How to do it...

To understand the effect of foreground and background threads on a program, perform the following:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file, add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

class ThreadSample
{
  private readonly int _iterations;

  public ThreadSample(int iterations)
  {
    _iterations = iterations;
  }
  public void CountNumbers()
  {
    for (int i = 0; i < _iterations; i++)
    {
      Thread.Sleep(TimeSpan.FromSeconds(0.5));
      Console.WriteLine("{0} prints {1}", Thread.CurrentThread.Name, i);
    }
  }
}

Add the following code snippet inside the Main method:

var sampleForeground = new ThreadSample(10);
var sampleBackground = new ThreadSample(20);

var threadOne = new Thread(sampleForeground.CountNumbers);
threadOne.Name = "ForegroundThread";
var threadTwo = new Thread(sampleBackground.CountNumbers);
threadTwo.Name = "BackgroundThread";
threadTwo.IsBackground = true;

threadOne.Start();
threadTwo.Start();

Run the program.

How it works...

When the main program starts it defines two different threads. By default, a thread we create explicitly is a foreground thread. To create a background thread, we manually set the IsBackground property of the threadTwo object to true. We configure these threads in a way that the first one will complete faster, and then we run the program.

After the first thread completes, the program shuts down and the background thread terminates. This is the main difference between the two: a process waits for all the foreground threads to complete before finishing the work, but if it has background threads, they just shut down.

It is also important to mention that if a program defines a foreground thread that does not complete, the main program will not end properly.

Passing parameters to a thread

This recipe will describe how to provide a code we run in another thread with the required data. We will go through the different ways to fulfill this task and review common mistakes.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe8.

How to do it...

To understand how to pass parameters to a thread, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file, add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void Count(object iterations)
{
  CountNumbers((int)iterations);
}

static void CountNumbers(int iterations)
{
  for (int i = 1; i <= iterations; i++)
  {
    Thread.Sleep(TimeSpan.FromSeconds(0.5));
    Console.WriteLine("{0} prints {1}", Thread.CurrentThread.Name, i);
  }
}
static void PrintNumber(int number)
{
  Console.WriteLine(number);
}

class ThreadSample
{
  private readonly int _iterations;

  public ThreadSample(int iterations)
  {
    _iterations = iterations;
  }
  public void CountNumbers()
  {
    for (int i = 1; i <= _iterations; i++)
    {
      Thread.Sleep(TimeSpan.FromSeconds(0.5));
      Console.WriteLine("{0} prints {1}", Thread.CurrentThread.Name, i);
    }
  }
}

Add the following code snippet inside the Main method:

var sample = new ThreadSample(10);

var threadOne = new Thread(sample.CountNumbers);
threadOne.Name = "ThreadOne";
threadOne.Start();
threadOne.Join();
Console.WriteLine("--------------------------");

var threadTwo = new Thread(Count);
threadTwo.Name = "ThreadTwo";
threadTwo.Start(8);
threadTwo.Join();
Console.WriteLine("--------------------------");

var threadThree = new Thread(() => CountNumbers(12));
threadThree.Name = "ThreadThree";
threadThree.Start();
threadThree.Join();
Console.WriteLine("--------------------------");

int i = 10;
var threadFour = new Thread(() => PrintNumber(i));
i = 20;
var threadFive = new Thread(() => PrintNumber(i));
threadFour.Start(); 
threadFive.Start();

Run the program.

How it works...

When the main program starts, it first creates an object of class ThreadSample, providing it with a number of iterations. Then we start a thread with the object's method CountNumbers. This method runs in another thread, but it uses the number 10, which is the value that we passed to the object's constructor. Therefore, we just passed this number of iterations to another thread in the same indirect way.

There's more…

Another way to pass data is to use the Thread.Start method by accepting an object that can be passed to another thread. To work this way, a method that we started in another thread must accept one single parameter of type object. This option is illustrated by creating a threadTwo thread. We pass 8 as an object to the Count method, where it is cast to an integer type.

The next option involves using lambda expressions. A lambda expression defines a method that does not belong to any class. We create such a method that invokes another method with the arguments needed and start it in another thread. When we start the threadThree thread, it prints out 12 numbers, which are exactly the numbers we passed to it via the lambda expression.

Using the lambda expressions involves another C# construct named closure. When we use any local variable in a lambda expression, C# generates a class and makes this variable a property of this class. So actually, we do the same thing as in the threadOne thread, but we do not define the class ourselves; the C# compiler does this automatically.

This could lead to several problems; for example, if we use the same variable from several lambdas, they will actually share this variable value. This is illustrated by the previous example; when we start threadFour and threadFive, they will both print 20 because the variable was changed to hold the value 20 before both threads were started.

Locking with a C# lock keyword

This recipe will describe how to ensure that if one thread uses some resource, another does not simultaneously use it. We will see why this is needed and what the thread safety concept is all about.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites The source code for this recipe can be found at BookSamples\Chapter1\Recipe9.

How to do it...

To understand how to use the C# lock keyword, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file, add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void TestCounter(CounterBase c)
{
  for (int i = 0; i < 100000; i++)
  {
    c.Increment();
    c.Decrement();
  }
}

class Counter : CounterBase
{
  public int Count { get; private set; }
  public override void Increment()
  {
    Count++;
  }

  public override void Decrement()
  {
    Count--;
  }
}

class CounterWithLock : CounterBase
{
  private readonly object _syncRoot = new Object();

  public int Count { get; private set; }

  public override void Increment()
  {
    lock (_syncRoot)
    {
      Count++;
    }
  }

  public override void Decrement()
  {
    lock (_syncRoot)
    {
      Count--;
    }
  }
}

abstract class CounterBase
{
  public abstract void Increment();
  public abstract void Decrement();
}

Add the following code snippet inside the Main method:

Console.WriteLine("Incorrect counter");

var c = new Counter();

var t1 = new Thread(() => TestCounter(c));
var t2 = new Thread(() => TestCounter(c));
var t3 = new Thread(() => TestCounter(c));
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();

Console.WriteLine("Total count: {0}",c.Count);
Console.WriteLine("--------------------------");
Console.WriteLine("Correct counter");

var c1 = new CounterWithLock();

t1 = new Thread(() => TestCounter(c1));
t2 = new Thread(() => TestCounter(c1));
t3 = new Thread(() => TestCounter(c1));
t1.Start();
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
Console.WriteLine("Total count: {0}", c1.Count);

Run the program.

How it works...

When the main program starts, it first creates an object of the class Counter. This class defines a simple counter that can be incremented and decremented. Then we start three threads that share the same counter instance and perform an increment and decrement in a cycle. This leads to nondeterministic results. If we run the program several times, it will print out several different counter values. It could be zero, but mostly won't be.

This happens because the Counter class is not thread safe. When several threads access the counter at the same time, the first thread gets the counter value 10 and increments it to 11. Then a second thread gets the value 11 and increments it to 12. The first thread gets the counter value 12, but before a decrement happens, a second thread gets the counter value 12 as well. Then the first thread decrements 12 to 11 and saves it into the counter, and the second thread simultaneously does the same. As a result, we have two increments and only one decrement, which is obviously not right. This kind of a situation is called race condition and is a very common cause of errors in a multithreaded environment.

To make sure that this does not happen, we must ensure that while one thread works with the counter, all other threads must wait until the first one finishes the work. We can use the lock keyword to achieve this kind of behavior. If we lock an object, all the other threads that require an access to this object will be waiting in a blocked state until it is unlocked. This could be a serious performance issue and later, in Chapter 2, Thread Synchronization, we will learn more about this.

Locking with a Monitor construct

This recipe illustrates another common multithreaded error called a deadlock. Since a deadlock will cause a program to stop working, the first piece in this example is a new Monitor construct that allows us to avoid a deadlock. Then, the previously described lock keyword is used to get a deadlock.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe10.

How to do it...

To understand the multithreaded error deadlock, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file, add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void LockTooMuch(object lock1, object lock2)
{
  lock (lock1)
  {
    Thread.Sleep(1000);
    lock (lock2);
  }
}

Add the following code snippet inside the Main method:

object lock1 = new object();
object lock2 = new object();

new Thread(() => LockTooMuch(lock1, lock2)).Start();

lock (lock2)
{
  Thread.Sleep(1000);
  Console.WriteLine("Monitor.TryEnter allows not to get stuck, returning false after a specified timeout is elapsed");
  if (Monitor.TryEnter(lock1, TimeSpan.FromSeconds(5)))
  {
    Console.WriteLine("Acquired a protected resource succesfully");
  }
  else
  {
    Console.WriteLine("Timeout acquiring a resource!");
  }
}
new Thread(() => LockTooMuch(lock1, lock2)).Start();

Console.WriteLine("----------------------------------");
lock (lock2)
{
  Console.WriteLine("This will be a deadlock!");
  Thread.Sleep(1000);
  lock (lock1)
  {
    Console.WriteLine("Acquired a protected resource succesfully");
  }
}

Run the program.

How it works...

Let's start with the LockTooMuch method. In this method, we just lock the first object, wait a second and then lock the second object. Then we start this method in another thread and try to lock the second object and then the first object from the main thread.

If we use the lock keyword like in the second part of this demo, it would be a deadlock. The first thread holds a lock on the lock1 object and waits while the lock2 object gets free; the main thread holds a lock on the lock2 object and waits for the lock1 object to become free, which in this situation will never happen.

Actually, the lock keyword is a syntactic sugar for Monitor class usage. If we were to disassemble a code with lock, we would see that it turns into the following code snippet:

bool acquiredLock = false;
try
{
  Monitor.Enter(lockObject, ref acquiredLock);

// Code that accesses resources that are protected by the lock.

}
finally
{
  if (acquiredLock)
  {
    Monitor.Exit(lockObject);
  }
}

Therefore, we can use the Monitor class directly; it has the TryEnter method, which accepts a timeout parameter and returns false if this timeout parameter expires before we can acquire the resource protected by lock.

Handling exceptions

This recipe will describe how to handle exceptions in other threads properly. It is very important to always place a try/catch block inside the thread because it is not possible to catch an exception outside a thread's code.

Getting ready

To work through this recipe, you will need Visual Studio 2012. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter1\Recipe11.

How to do it...

To understand the handling of exceptions in other threads, perform the following steps:

Start Visual Studio 2012. Create a new C# Console Application project.
In the Program.cs file add the following using directives:
```
using System;
using System.Threading;
```

Add the following code snippet below the Main method:

static void BadFaultyThread()
{
  Console.WriteLine("Starting a faulty thread...");
  Thread.Sleep(TimeSpan.FromSeconds(2));
  throw new Exception("Boom!");
}

static void FaultyThread()
{
  try
  {
    Console.WriteLine("Starting a faulty thread...");
    Thread.Sleep(TimeSpan.FromSeconds(1));
    throw new Exception("Boom!");
  }
  catch (Exception ex)
  {
    Console.WriteLine("Exception handled: {0}", ex.Message);
  }
}

Add the following code snippet inside the Main method:

var t = new Thread(FaultyThread);
t.Start();
t.Join();

try
{
  t = new Thread(BadFaultyThread);
  t.Start();
}
catch (Exception ex)
{
  Console.WriteLine("We won't get here!");
}

Run the program.

How it works...

When the main program starts, it defines two threads that will throw an exception. One of these threads handles exception, while the other does not. You can see that the second exception is not caught by a try/catch block around a code that starts the thread. So if you work with threads directly, the general rule is to not throw an exception from a thread, but to use a try/catch block inside a thread code instead.

In the older versions of .NET Framework (1.0 and 1.1), this behavior was different and uncaught exceptions did not force an application shutdown. It is possible to use this policy by adding an application configuration file (such as app.config) containing the following code snippet:

<configuration>
  <runtime>
    <legacyUnhandledExceptionPolicy enabled="1" />
  </runtime>
</configuration>

Multithreading in C# 5.0 Cookbook: Multithreaded programming can seem overwhelming but this book clarifies everything through its cookbook approach. Packed with practical tasks, it's the quick and easy way to start delving deep into the power of multithreading in C#.

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Key benefits

Description

Who is this book for?

What you will learn

Product Details

What do you get with Print?

Contact Details

Shipping Address

Billing Address

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

People who bought this also bought

About the author

FAQs