Threading & Life Cycle of Thread Concepts in C#

Introduction:

C# threading allows developers to create multiple threads in C# and .NET. 

Windows generates a process with a process id when a new application is launched, and resources are allotted to this new process. Every process has at least one primary thread that manages the application execution’s entry point. A single thread can only follow one path of execution, however is was already mentioned that threads might sometimes follow many courses of execution.

In C#, a thread represents an independent unit of execution within a process. Threads allow you to perform multiple tasks concurrently, improving the responsiveness and performance of your program. Here’s an overview of the thread concept in C#:

1. Thread Class:
   • The Thread class, located in the System.Threading namespace, is used to create and manage threads in C#.
   • You can create a new thread by instantiating the Thread class and passing a delegate (a method) to its constructor.
   • The delegate represents the code that the thread will execute.
2. Starting a Thread:
   • To start a thread, you call its Start() method.
   • When Start() is invoked, the thread begins executing the code specified by the delegate assigned to it.
   • Each thread executes independently, allowing multiple threads to run concurrently.
3. Thread Synchronization:
   • When multiple threads access shared resources or data concurrently, it can lead to race conditions and data corruption.
   • Thread synchronization techniques, such as locks, mutexes, and semaphores, are used to coordinate access to shared resources and ensure thread safety.
   • Synchronization mechanisms help prevent data corruption and ensure that threads access shared resources in a mutually exclusive manner.
4. Joining Threads:
   • The Join() method allows a thread to wait for another thread to complete its execution.
   • By calling Join() on a thread, the calling thread will pause until the target thread finishes executing.
   • Joining threads is useful when you want to ensure that certain threads have completed their work before proceeding further.
5. Background Threads:
   • Threads can be marked as either foreground or background threads.
   • Background threads do not prevent the application from terminating, even if they are still running.
   • Foreground threads, on the other hand, keep the application alive until they complete their execution.
   • By default, threads created in C# are foreground threads, but you can explicitly mark them as background threads using the IsBackground property.

Life Cycle of Thread:

The life cycle of a thread in C# refers to the various states a thread goes through from its creation until its termination. Understanding the thread life cycle is crucial for effectively managing and coordinating threads in a multithreaded application. Here’s an explanation of the different stages in the life cycle of a thread:

1. New:
   • The thread is in the “New” state immediately after it is created using the Thread class constructor.
   • In this state, the thread has been instantiated, but the underlying operating system thread has not been created yet.
2. Runnable/Ready:
   • When the Start() method is called on a thread object, the thread enters the “Runnable” state.
   • In this state, the thread is ready to run and can be scheduled for execution by the operating system.
3. Running:
   • When the operating system scheduler assigns processor time to a thread, it enters the “Running” state.
   • The thread’s code is currently being executed on one of the available CPU cores.
4. Blocked/Waiting/Sleeping:
   • A thread can transition to a blocked state for various reasons, such as waiting for a lock or synchronization primitive, waiting for I/O operations, or calling the Thread.Sleep() method.
   • While in the blocked state, the thread temporarily gives up its execution time and waits until the blocking condition is resolved.
   • Once the blocking condition is satisfied, the thread moves back to the “Runnable” state.
5. Terminated/Dead:
   • A thread can reach the “Terminated” state in several ways, such as completing its execution or encountering an exception that is not handled.
   • Once a thread is terminated, its resources are released, and it cannot be restarted.
6. Aborted:
   • A thread can be forcefully terminated by calling the Abort() method on the Thread object.
   • This causes the thread to abruptly terminate, potentially leaving the application or shared resources in an inconsistent state.
   • It is generally recommended to avoid using thread abortion as it can lead to unpredictable and undesirable consequences.
   • Additionally, a thread can also be in the “Suspended” state temporarily if it is explicitly suspended using the Suspend() method or by entering a native code block.

Here’s a simple example that demonstrates the thread concept in C#:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace MultithreadingSample
{
    internal class Threadsampple
    {
        static void Main()
        {
            // Creating a new thread and starting it
            Thread thread = new Thread(WorkerMethod);
            thread.Start();

            // Executing code on the Main Thread
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Main Thread: " + i);
                Thread.Sleep(100);
            }

            // Waiting for the worker thread to complete
            thread.Join();

            Console.WriteLine("Main Thread finished execution.");
        }

        static void WorkerMethod()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Worker Thread: " + i);
                Thread.Sleep(200);
            }
        }
    }


}

• In the above code we have created a new thread and executed the main thread.
• The thread is waiting for the worker thread to complete the execution and then prints the thread value.
• And then the worker method starts the iteration process to execute the function and prints the thread in the output.

Code Output:

In this example, we create a new thread using the Thread class and pass the WorkerMethod as the delegate to its constructor. The Main Thread and the worker thread execute concurrently. The output may vary on each execution, but it will demonstrate the concurrent execution of both threads.

By using the Join() method, we make the Main Thread wait for the worker thread to complete before proceeding further. This ensures that both threads finish their execution before the program exits.

Remember to handle synchronization and thread safety when multiple threads access shared resources to avoid data corruption or race conditions.

Conclusion:

• This is a basic overview of the thread concept in C#. There are more advanced topics like thread pooling, asynchronous programming, and parallelism that you can explore to further enhance your understanding of multithreading in C#.
• Understanding the life cycle of a thread helps in designing and coordinating multithreaded applications effectively. Proper synchronization mechanisms and coordination techniques, such as locks, semaphores, and signaling, are used to manage the execution and interdependencies between threads.
• It’s important to note that the specific behavior of thread states and transitions may vary depending on the underlying operating system and its thread scheduling algorithm.
• I hope this explanation clarifies the threading concepts and the life cycle of a thread in C#. Other detailed concepts of threading will be covered in the upcoming blogs.