C# Multithreading with Examples

What is Multithreading in C#

Multithreading is one of the most powerful techniques for achieving this in C#. Multithreading refers to a program's ability to run multiple threads at the same time, allowing for parallel processing and increasing overall application efficiency.

Understanding Threads

A thread is a single sequence of instructions or a flow of control within a program in computing. Most applications have traditionally run as single-threaded processes, which means they execute instructions one after the other. However, modern CPUs have multiple cores, and not using them to their full potential means wasting valuable computing power.

This is where multithreading comes in. A program can use multithreading to create and manage multiple threads within a single process. Each thread represents a separate flow of control that can execute its own set of instructions concurrently with other threads, possibly on different CPU cores. Concurrent execution enables tasks to be completed more quickly and efficiently, resulting in improved application performance and responsiveness.

Let us see an example of multithreading in C#:

Output

This is the basic example of creating and working with threads in C# in which we have created a thread and assigned the task to that thread.

Thread priorities in C#

Each thread in the C# Programming Language has a priority, which controls how frequently the thread has access to the CPU. The crucial thing to realize is that how much CPU time a thread receives is determined not only by its priority but also by the type of activity it is conducting. However, it is critical to use thread priorities wisely, as too many high-priority threads can starve lower-priority threads.

Properties of Thread Priority

1. Lowest = 0: Threads with the lowest priority can be scheduled after threads with higher priorities.
2. BelowNormal = 1: Threads with BelowNormal priority might be scheduled before Threads with Lowest priority and after Threads with Normal priority.
3. Normal = 2: Normal priority threads can be scheduled after AboveNormal priority threads and before BelowNormal and Lowest priority threads.
4. AboveNormal = 3: AboveNormal priority threads can be scheduled after the Highest priority thread and before Normal, BelowNormal, and Lowest priority threads.
5. Highest = 4: Threads with the highest priority can be scheduled ahead of threads with lower priorities.

How to set the Priority of the Thread

When we create a Thread with no Priority, the default Priority is set to Normal.

Using the Priority property of the Thread class, we can get or set the thread's priority.

• ThreadPriority Priority {get; set;}: The ThreadPriority property is used to get or set the thread priority. It returns the ThreadPriority values of the thread. The default value is ThreadPriority.Normal.

Now, let's see an example for setting the Priority of the thread:

Example:

Output:

In this example, we first use Thread.CurrentThread to get the priority of the current thread. Before creating and starting the new thread, set the priority and print it to the console. Then, within MyThreadFunction, we retrieve the current thread's priority using the same method to ensure that it is the same as the ThreadPriority.Highest as we set earlier.

Thread Lifecycle

A thread's lifetime refers to the various phases that a thread passes through from the time it is created until it completes its execution or is terminated. Understanding the thread lifecycle is critical for managing threads successfully in a multithreaded application. The thread lifetime in C# has various states:

1. Unstarted State:
   • Thread status is Unstarted until its Start() method is called.
2. Runnable State:
   • The thread enters the runnable state after using the Start() function.
   • The thread is not now active on a CPU core, although it is eligible for execution.
3. Running State:
   • When the thread scheduler assigns the CPU time to the particular thread, it enters the running state.
   • In this state, the thread code is actively executing the task on a CPU core.
4. Not Runnable State:
   • Threads can enter the not runnable state when they are waiting for some condition to be satisfied before they can continue executing.
   • Once the blocking condition is met, the thread moves back to the runnable state.
5. Dead State:
   • A thread enters the dead state when its execution is completed or when it is explicitly terminated.
   • Threads can naturally terminate when their method execution completes or when an unhandled exception occurs.
   • Explicitly terminating threads using the Abort() method is discouraged due to potential issues with resource cleanup and thread safety.

The Thread Class in C#

The Thread class in C# is a basic class offered by the .NET Framework for establishing and managing threads. It enables developers to work with multithreading and parallelism, allowing numerous threads to run concurrently within a single process. The Thread class is defined in the System. Threading namespace.

Let's look at some of the Thread class's most important features:

Constructors

The Thread class provides several various constructors to create instances of threads. The commonly used constructors are as follows:

Properties

The Thread class provides several various properties for the threads. The commonly used properties are as follows:

Methods

The Thread class provides several various methods for thread execution. The commonly used methods are as follows:

Creating a Thread

For creating a thread using the Thread class, we need to follow these steps:

1. Define the method that will be executed by the thread. This method's signature must match that of the delegate (ThreadStart or ParameterizedThreadStart).
2. Create a Thread instance by passing the method as an argument to the appropriate constructor.
3. Set the thread's name and priority using the Name and Priority properties, if desired.
4. To begin the thread's execution, use the Start() method.

Here's an example of creating a simple thread using the Thread class:

In this example, we define the MyThreadFunction() method, which will be executed by the new thread. We created a Thread instance called myThread and gave it a name and a priority. We then use the Start() method to start the thread and the Join() method to wait for it to finish before continuing with the main thread's execution.

Advantages of Multithreading

• Improved Performance: Multithreading allows multiple tasks to be executed concurrently, effectively utilizing multiple CPU cores.
• Responsiveness: The main thread remains responsive to user interactions by offloading time-consuming operations to separate threads.
• Resource Utilization: Because threads can handle concurrent operations efficiently, multithreading improves resource utilization.
• Scalability: Multithreading improves scalability by allowing applications to handle multiple requests at the same time.
• Background Processing: Multithreading is required for implementing background tasks such as file downloads, data processing, and so on while keeping the UI responsive.