Book Image

Multithreading with C# Cookbook, Second Edition - Second Edition

By : Evgenii Agafonov
Book Image

Multithreading with C# Cookbook, Second Edition - Second Edition

By: Evgenii 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#.
Table of Contents (18 chapters)
Multithreading with C# Cookbook Second Edition
About the Author
About the Reviewers

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 System;
    using System.Threading;
    using static System.Console;
    using static System.Threading.Thread;
    using 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;
      threadTwo.Priority = ThreadPriority.Lowest;
    class ThreadSample
      private bool _isStopped = false;
      public void Stop()
        _isStopped = true;
      public void CountNumbers()
        long counter = 0;
        while (!_isStopped)
        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");
    WriteLine("Running on a single core");
    GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
  5. Run the program.

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.