Fr

ee

Multithreading with C# Cookbook Second Edition

Rewritten to the latest C# specification, C# 6, and updated with new and modern recipes to help you make
the most of the hardware you have available, this book will help you push the boundaries of what you
thought possible in C#.

What this book will do

for you...
Use C# 6.0 asynchronous language features
Work with raw threads, synchronize threads,

and coordinate their work

Develop your own asynchronous API with

Task Parallel Library

Work effectively with a thread pool

Inside the Cookbook...

Scale up your server application with

A straightforward and easy-to-follow format

I/O threads

A selection of the most important tasks

Parallelize your LINQ queries with PLINQ

Use common concurrent collections
Apply different parallel programming patterns

operations and manage their options

Carefully organized instructions to solve

problems efficiently

Clear explanations of what you did

Solutions that can be applied to solve

real-world problems

$ 49.99 US
31.99 UK

community experience distilled

P U B L I S H I N G

Prices do not include

local sales tax or VAT
where applicable

P U B L I S H I N G

Visit www.PacktPub.com for books, eBooks,

code, downloads, and PacktLib.

Eugene Agafonov

Use Reactive Extensions to run asynchronous

and problems

Multithreading with C# Cookbook Second Edition

Multithreading with C# Cookbook, Second Edition is an easy-to-follow guide that will show you difficult
programming problems in context. You will learn how to solve them with practical, hands-on recipes. With
these recipes, you'll be able to start creating your own scalable and reliable multithreaded applications.
Starting from learning what a thread is, we guide you through the basics and then move on to more advanced
concepts such as Task Parallel Libraries, C# asynchronous functions, and much more.

Sa

pl
e

Quick answers to common problems

Multithreading with
C# Cookbook
Second Edition
Over 70 recipes to get you writing powerful and efficient
multithreaded, asynchronous, and parallel programs in C# 6.0

Eugene Agafonov

In this package, you will find:

The author biography

A preview chapter from the book, Chapter 1 'Threading Basics'
A synopsis of the books content
More information on Multithreading with C# Cookbook Second Edition

About the Author

Eugene Agafonov leads the development department at ABBYY and lives in Moscow.
He has over 15 years of professional experience in software development, and he started
working with C# when it was in beta version. He is a Microsoft MVP in ASP.NET since 2006,
and he often speaks at local software development conferences, such as DevCon Russia,
about cutting-edge technologies in modern web and server-side application development. His
main professional interests are cloud-based software architecture, scalability, and reliability.
Eugene is a huge fan of football and plays the guitar with a local rock band. You can reach him
at his personal blog, eugeneagafonov.com, or find him on Twitter at @eugene_agafonov.
ABBYY is a global leader in the development of document recognition, content capture, and
language-based technologies and solutions that are integrated across the entire information
life cycle.
He is the author of Multhreading in C# 5.0 Cookbook and Mastering C# Concurrency
by Packt Publishing.

Preface
Not so long ago, a typical personal computer CPU had only one computing core, and the
power consumption was enough to cook fried eggs on it. In 2005, Intel introduced its first
multiple-core CPU, and since then, computers started developing in a different direction.
Low-power consumption and a number of computing cores became more important than
a row computing core performance. This lead to programming paradigm changes as well.
Now, we need to learn how to use all CPU cores effectively to achieve the best performance,
and at the same time, we need to save battery power by running only the programs that we
need at a particular time. Besides that, we need to program server applications in a way to
use multiple CPU cores or even multiple computers as efficiently as possible to support as
many users as we can.
To be able to create such applications, you have to learn to use multiple CPU cores in your
programs effectively. If you use the Microsoft .NET development platform and C#, this book
will be a perfect starting point for you to program fast and responsive applications.
The purpose of this book is to provide you with a step-by-step guide for multithreading and
parallel programming in C#. We will start with the basic concepts, going through more and
more advanced topics based on the information from previous chapters, and we will end with
real-world parallel programming patterns, Universal Windows applications, and cross-platform
applications samples.

What this book covers

Chapter 1, Threading Basics, introduces the basic operations with threads in C#. It explains
what a thread is, the pros and cons of using threads, and other important thread aspects.
Chapter 2, Thread Synchronization, describes thread interaction details. You will learn why we
need to coordinate threads together and the different ways of organizing thread coordination.
Chapter 3, Using a Thread Pool, explains the thread pool concept. It shows how to use a
thread pool, how to work with asynchronous operations, and the good and bad practices
of using a thread pool.

Preface
Chapter 4, Using the Task Parallel Library, is a deep dive into the Task Parallel Library (TPL)
framework. This chapter outlines every important aspect of TPL, including task combination,
exception management, and operation cancelation.
Chapter 5, Using C# 6.0, explains in detail the recently introduced C# featureasynchronous
methods. You will find out what the async and await keywords mean, how to use them in
different scenarios, and how await works under the hood.
Chapter 6, Using Concurrent Collections, describes the standard data structures for parallel
algorithms included in .NET Framework. It goes through sample programming scenarios for
each data structure.
Chapter 7, Using PLINQ, is a deep dive into the Parallel LINQ infrastructure. The chapter
describes task and data parallelism, parallelizing a LINQ query, tweaking parallelism options,
partitioning a query, and aggregating the parallel query result.
Chapter 8, Reactive Extensions, explains how and when to use the Reactive Extensions
framework. You will learn how to compose events and how to perform a LINQ query against
an event sequence.
Chapter 9, Using Asynchronous I/O, covers in detail the asynchronous I/O process, including
files, networks, and database scenarios.
Chapter 10, Parallel Programming Patterns, outlines the solutions to common parallel
programming problems.
Chapter 11, There's More, covers the aspects of programming asynchronous applications for
Windows 10, OS X, and Linux. You will learn how to work with Windows 10 asynchronous APIs
and how to perform the background work in Universal Windows applications. Also, you will get
familiar with cross-platform .NET development tools and components.

Threading Basics
In this chapter, we will cover the basic tasks to work with threads in C#. You will learn the
following recipes:

Creating a thread in C#

Pausing a thread

Making a thread wait

Aborting a thread

Determining a 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

Threading Basics

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 as a virtual
processor that is given to the one specific program and runs it independently.
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 that communicate and synchronize with each other.
The recipes in this chapter focus on performing some very basic operations with threads
in the C# language. We will cover a thread's life cycle, which includes creating, suspending,
making a thread wait, and aborting a thread, and then, we will go through the basic
synchronization techniques.

Creating a thread in C#
Throughout the following recipes, we will use Visual Studio 2015 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.
A free Visual Studio Community 2015 IDE can be downloaded from
the Microsoft website and used to run the code samples.
2

Chapter 1

Getting ready
To work through this recipe, you will need Visual Studio 2015. There are no other
prerequisites. The source code for this recipe can be found in the BookSamples\Chapter1\
Recipe1 directory.
Downloading the example code
You can download the example code files for this book from 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.
You can download the code files by following these steps:

Log in or register to our website using your e-mail address and

password.

Hover the mouse pointer on the SUPPORT tab at the top.

Click on Code Downloads & Errata.

Enter the name of the book in the Search box.

Select the book for which you're looking to download the code files.

Choose from the drop-down menu where you purchased this book from.

Click on Code Download.

Once the file is downloaded, please make sure that you unzip or extract the
folder using the latest version of:

WinRAR/7-Zip for Windows

Zipeg/iZip / UnRarX for Mac

7-Zip/PeaZip for Linux

How to do it...
To understand how to create a new C# program and use threads in it, perform the
following steps:
1. Start Visual Studio 2015. Create a new C# console application project.

Threading Basics
2. Make sure that the project uses .NET Framework 4.6 or higher; however, the code in
this chapter will work with previous versions.

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

using System;
using System.Threading;
using static System.Console;

4. Add the following code snippet below the Main method:

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

Chapter 1
5. Add the following code snippet inside the Main method:
Thread t = new Thread(PrintNumbers);
t.Start();
PrintNumbers();

6. Run the program. The output will be something like the following screenshot:

How it works...
In step 1 and 2, we created a simple console application in C# using .Net Framework version
4.0. Then, in step 3, we included the System.Threading namespace, which contains all the
types needed for the program. Then, we used the using static feature from C# 6.0, which
allows us to use the System.Console type's static methods without specifying the type name.
An instance of a program that 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 PrintNumbers method, 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 creates 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.
5

Threading Basics
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 2015. 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 resources,
perform the following steps:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using
using
using
using

System;
System.Threading;
static System.Console;
static System.Threading.Thread;

3. Add the following code snippet below the Main method:

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

Chapter 1
WriteLine(i);
}
}

4. Add the following code snippet inside the Main method:

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

5. 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 the thread executing this code to wait a
specified amount of time (2 seconds in our case) before printing each number. While a thread
sleeps, it uses as little CPU time as possible. As a result, we will see that the code in the
PrintNumbers method, which 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 the Thread.Sleep
method because we don't know the exact time the computation will take.

Getting ready
To work through this recipe, you will need Visual Studio 2015. 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 waits for some computation in another thread to complete in
order to use its result later, perform the following steps:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using System;
using System.Threading;

Threading Basics
using static System.Console;
using static System.Threading.Thread;

3. Add the following code snippet below the Main method:

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

4. Add the following code snippet inside the Main method:

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

5. 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 the thread t to complete working. 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 waits, 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 2015. There are no other prerequisites.
The source code for this recipe can be found at BookSamples\Chapter1\Recipe4.

Chapter 1

How to do it...
To understand how to abort another thread's execution, perform the following steps:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using System;
using System.Threading;
using static System.Console;

3. Using the static System.Threading.Thread, add the following code snippet below
the Main method:
static void PrintNumbersWithDelay()
{
WriteLine("Starting...");
for (int i = 1; i < 10; i++)
{
Sleep(TimeSpan.FromSeconds(2));
WriteLine(i);
}
}

4. Add the following code snippet inside the Main method:

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

5. Run the program.

Threading Basics

How it works...
When the main program and a separate number-printing thread run, we wait for six 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 by 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 object 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 the 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. 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 2015. 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:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using
using
using
using

System;
System.Threading;
static System.Console;
static System.Threading.Thread;

3. Add the following code snippet below the Main method:

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

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

4. Add the following code snippet inside the Main method:

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

5. 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.
Note that the current Thread object is always accessible through
the Thread.CurrentThread static property.

11

Threading Basics
If this 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. 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 was completed successfully and now has a
ThreadState.Stopped state. There are several other states, but they are partly deprecated
and not as useful as those we examined.

Thread priority
This recipe will describe the different 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 2015. 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:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using
using
using
using
using

System;
System.Threading;
static System.Console;
static System.Threading.Thread;
static System.Diagnostics.Process;

3. 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;
12

Chapter 1
threadTwo.Priority = ThreadPriority.Lowest;
threadOne.Start();
threadTwo.Start();
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++;
}
WriteLine($"{CurrentThread.Name} with " +
$"{CurrentThread.Priority,11} priority " +
$"has a count = {counter,13:N0}");
}
}

4. Add the following code snippet inside the Main method:

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

5. Run the program.

13

Threading Basics

How it works...
When the main program starts, it defines two different threads. The first one, threadOne,
has the highest thread priority ThreadPriority.Highest, while the second one, that
is threadTwo, has the lowest ThreadPriority.Lowest priority. 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 1). Now, the results
should be very different, and the calculations will take more than two seconds. This happens
because the CPU core runs mostly the high-priority thread, giving the rest of the threads very
little time.
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 2015. 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 steps:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using
using
using
using

14

System;
System.Threading;
static System.Console;
static System.Threading.Thread;

Chapter 1
3. 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++)
{
Sleep(TimeSpan.FromSeconds(0.5));
WriteLine($"{CurrentThread.Name} prints {i}");
}
}
}

4. 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();

5. Run the program.

How it works...
When the main program starts, it defines two different threads. By default, a thread that 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 be completed faster, and then we run the program.

15

Threading Basics
After the first thread is complete, the program shuts down and the background thread is
terminated. 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 get
completed; the main program does not end properly.

Passing parameters to a thread

This recipe will describe how to provide code that 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 2015. 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:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using
using
using
using

System;
System.Threading;
static System.Console;
static System.Threading.Thread;

3. 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++)
{
Sleep(TimeSpan.FromSeconds(0.5));
WriteLine($"{CurrentThread.Name} prints {i}");
}

16

Chapter 1
}
static void PrintNumber(int number)
{
WriteLine(number);
}
class ThreadSample
{
private readonly int _iterations;
public ThreadSample(int iterations)
{
_iterations = iterations;
}
public void CountNumbers()
{
for (int i = 1; i <= _iterations; i++)
{
Sleep(TimeSpan.FromSeconds(0.5));
WriteLine($"{CurrentThread.Name} prints {i}");
}
}
}

4. 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();
WriteLine("--------------------------");
var threadTwo = new Thread(Count);
threadTwo.Name = "ThreadTwo";
threadTwo.Start(8);
threadTwo.Join();
WriteLine("--------------------------");
var threadThree = new Thread(() => CountNumbers(12));
threadThree.Name = "ThreadThree";
17

Threading Basics
threadThree.Start();
threadThree.Join();
WriteLine("--------------------------");
int i = 10;
var threadFour = new Thread(() => PrintNumber(i));
i = 20;
var threadFive = new Thread(() => PrintNumber(i));
threadFour.Start();
threadFive.Start();

5. Run the program.

How it works...
When the main program starts, it first creates an object of the ThreadSample
class, providing it with a number of iterations. Then, we start a thread with the object's
CountNumbers method. 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 the 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 the use of 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.
The use of 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 where, when we start threadFour and threadFive, they both print 20 because
the variable was changed to hold the value 20 before both threads were started.

18

Chapter 1

Locking with a C# lock keyword

This recipe will describe how to ensure that when 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 2015. 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:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using System;
using System.Threading;
using static System.Console;

3. 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()

19

Threading Basics
{
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();
}

4. Add the following code snippet inside the Main method:

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();
20

Chapter 1
t2.Start();
t3.Start();
t1.Join();
t2.Join();
t3.Join();
WriteLine($"Total count: {c.Count}");
WriteLine("--------------------------");
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();
WriteLine($"Total count: {c1.Count}");

5. Run the program.

How it works...
When the main program starts, it first creates an object of the Counter class. 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 0, 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 takes place, 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 a race condition
and is a very common cause of errors in a multithreaded environment.

21

Threading Basics
To make sure that this does not happen, we must ensure that while one thread works with the
counter, all other threads 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 wait in a blocked state until it is unlocked. This could be a serious performance
issue and later, in Chapter 2, Thread Synchronization, you 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 2015. 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:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using
using
using
using

System;
System.Threading;
static System.Console;
static System.Threading.Thread;

3. Add the following code snippet below the Main method:

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

4. Add the following code snippet inside the Main method:

object lock1 = new object();

22

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

5. Run the program.

How it works...
Let's start with the LockTooMuch method. In this method, we just lock the first object, wait
for 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, there will 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 will never happen in this situation.
23

Threading Basics
Actually, the lock keyword is syntactic sugar for the Monitor class usage. If we were to
disassemble 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 2015. 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:
1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:
using System;
using System.Threading;

24

Chapter 1
using static System.Console;
using static System.Threading.Thread;

3. Add the following code snippet below the Main method:

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

4. 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)
{
WriteLine("We won't get here!");
}

5. Run the program.

25

Threading Basics

How it works...
When the main program starts, it defines two threads that will throw an exception. One of
these threads handles an exception, while the other does not. You can see that the second
exception is not caught by a try/catch block around the 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) that contains the following
code snippet:
<configuration>
<runtime>
<legacyUnhandledExceptionPolicy enabled="1" />
</runtime>
</configuration>

26

Get more information Multithreading with C# Cookbook Second Edition

Where to buy this book

You can buy Multithreading with C# Cookbook Second Edition from the
Packt Publishing website.
Alternatively, you can buy the book from Amazon, BN.com, Computer Manuals and most internet
book retailers.
Click here for ordering and shipping details.

www.PacktPub.com

Stay Connected: