Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Multithreading with C# Cookbook, Second Edition

By : Agafonov

2.8 (4)

Multithreading with C# Cookbook, Second Edition

2.8 (4)

By: Agafonov

Overview of this book

Multi-core processors are synonymous with computing speed and power in today’s world, which is why multithreading has become a key concern for C# developers. Multithreaded code helps you create effective, scalable, and responsive applications. This 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. 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#.

Preface

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Free Chapter

1. Threading Basics

1. Threading Basics

Introduction

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

2. Thread Synchronization

2. Thread Synchronization

Introduction

Performing basic atomic operations

Using the Mutex construct

Using the SemaphoreSlim construct

Using the AutoResetEvent construct

Using the ManualResetEventSlim construct

Using the CountDownEvent construct

Using the Barrier construct

Using the ReaderWriterLockSlim construct

Using the SpinWait construct

3. Using a Thread Pool

3. Using a Thread Pool

Introduction

Invoking a delegate on a thread pool

Posting an asynchronous operation on a thread pool

A thread pool and the degree of parallelism

Implementing a cancellation option

Using a wait handle and timeout with a thread pool

Using a timer

Using the BackgroundWorker component

4. Using the Task Parallel Library

4. Using the Task Parallel Library

Introduction

Creating a task

Performing basic operations with a task

Combining tasks

Converting the APM pattern to tasks

Converting the EAP pattern to tasks

Implementing a cancelation option

Handling exceptions in tasks

Running tasks in parallel

Tweaking the execution of tasks with TaskScheduler

5. Using C# 6.0

5. Using C# 6.0

Introduction

Using the await operator to get asynchronous task results

Using the await operator in a lambda expression

Using the await operator with consequent asynchronous tasks

Using the await operator for the execution of parallel asynchronous tasks

Handling exceptions in asynchronous operations

Avoiding the use of the captured synchronization context

Working around the async void method

Designing a custom awaitable type

Using the dynamic type with await

6. Using Concurrent Collections

6. Using Concurrent Collections

Introduction

Using ConcurrentDictionary

Implementing asynchronous processing using ConcurrentQueue

Changing asynchronous processing order with ConcurrentStack

Creating a scalable crawler with ConcurrentBag

Generalizing asynchronous processing with BlockingCollection

7. Using PLINQ

7. Using PLINQ

Introduction

Using the Parallel class

Parallelizing a LINQ query

Tweaking the parameters of a PLINQ query

Handling exceptions in a PLINQ query

Managing data partitioning in a PLINQ query

Creating a custom aggregator for a PLINQ query

8. Reactive Extensions

8. Reactive Extensions

Introduction

Converting a collection to an asynchronous Observable

Writing custom Observable

Using the Subject type family

Creating an Observable object

Using LINQ queries against an observable collection

Creating asynchronous operations with Rx

9. Using Asynchronous I/O

9. Using Asynchronous I/O

Introduction

Working with files asynchronously

Writing an asynchronous HTTP server and client

Working with a database asynchronously

Calling a WCF service asynchronously

10. Parallel Programming Patterns

10. Parallel Programming Patterns

Introduction

Implementing Lazy-evaluated shared states

Implementing Parallel Pipeline with BlockingCollection

Implementing Parallel Pipeline with TPL DataFlow

Implementing Map/Reduce with PLINQ

11. There's More

11. There's More

Introduction

Using a timer in a Universal Windows Platform application

Using WinRT from usual applications

Using BackgroundTask in Universal Windows Platform applications

Running a .NET Core application on OS X

Running a .NET Core application on Ubuntu Linux

Index

Index

Customer Reviews

2.8 (4)

5 star

25%

4 star

0

3 star

0

2 star

75%

1 star

0

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.

How to do it...

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

Start Visual Studio 2015. Create a new C# console application project.

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

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

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);
  }
}

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

Run the program.

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.

Search

Your notes and bookmarks