Multithreading in C#

Multithreading is a method to implement concurrent programming where multiple threads operate simultaneously. Threads are lightweight processes that signify the execution path in a program. Thread usage increases the efficiency of an application and reduces the CPU cycle time wastage.

The Thread Life Cycle

The thread life cycle encapsulates the life of a thread. It starts when an object of System.Threading.Thread class is created and ends when thread has terminated. The thread states in the thread life cycle are given as follows:

1. Unstarted State

When the instance of the thread has been created but the Start method has not been called, that is the unstarted state.

2. Ready State

When the thread is ready to run, it is in the ready state. This thread is just waiting for the CPU cycle.

3. Not runnable State

A thread can be in the not runnable state when the wait or sleep method has been called. This state can also occur if the thread is blocked because of I/O operations.

4. Dead State

The thread enters the dead state if it is aborted or if it has completed its execution.

The Thread Class

The System.Threading namespace provides the classes and interfaces that implement multithreaded programming. One of the classes in this namespace is the Thread class. This class is used for creating and controlling threads.

Details about the constructors, properties and methods in Thread Class are given as follows:

Constructors in Thread Class

The different constructors and their description is given as follows:

Table: Constructors in Thread Class in C#

Source: MSDN

Properties in Thread Class

The different properties and their description is given as follows:

Table: Properties in Thread Class in C#

Source: MSDN

Methods in Thread Class

The different methods and their description is given as follows:

Table: Methods in Thread Class in C#

Source: MSDN

Create a Thread

To create a Thread, simply use the Thread class:

Source Code: Program to create a Thread in C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
class Example
{
   public void FirstThread()
   {
       for (int i = 0; i < 5; i++)
       {
           Console.WriteLine("My Thread");
       }
   }
}
class Sample
{
   public static void Main()
   {
       Example e = new Example();
       Thread t = new Thread(new ThreadStart(e.FirstThread));
       t.Start();
       Console.Read();
   }
}

The above program generates the following output:

My Thread
My Thread
My Thread
My Thread
My Thread

The Main Thread

The Main Thread is the first thread that is created and executed inside a process. It is automatically created when the process starts execution.

A program that demonstrates the Main thread is given as follows:

Source Code: Program to implement Main Thread in C#

using System;
using System.Threading;
namespace MultithreadingDemo
{
  class Example
  {
     static void Main(string[] args)
     {
        Thread myThread = Thread.CurrentThread;
        myThread.Name = "Main_Thread";
        Console.WriteLine("This thread is the {0}", myThread.Name);
     }
  }
}

The output of the above program is as follows:

This thread is the Main_Thread

Now let us understand the above program.

The CurrentThread property of the Thread class is used to access the Main thread. The name of the thread is specified is Main_Thread. After that, this is displayed. The code snippet for this is given as follows:

    Thread myThread = Thread.CurrentThread;
        myThread.Name = "Main_Thread";
        Console.WriteLine("This thread is the {0}", myThread.Name);

Check status of Current Thread

The isAlive property is to be used if you want to check the status of current Thread in C#.

Let us see an example:

Source Code: Program to check the status of current Thread in C#

using System;
using System.Threading;
namespace Example
{
   class MyThread
   {
       static void Main(string[] args)
       {
           Thread t = Thread.CurrentThread;
           t.Name = "This is my first thread!";
           Console.WriteLine("Status of current thread = {0}", t.IsAlive);
           Console.ReadKey();
       }
   }
}

The above program generates the following output:

Status of current thread = True

Get the name of Current Thread

To get the name of the current thread, you need to use the Name property of the Thread class. Let us see an example:

Source Code: Program to get the name of current Thread in C#

using System;
using System.Threading;
namespace Demo
{
   class MyClass
   {
       static void Main(string[] args)
       {
           Thread t = Thread.CurrentThread;
           t.Name = "First Thread";
           Console.WriteLine("Name of thread : {0}", t.Name);
           Console.ReadKey();
       }
   }
}

The above program generates the following output:

Name of thread : First Thread

Display the priority of the Current Thread

The Priority property of the Thread class is to be used for displaying the priority of the Current Thread:

Source Code: Program to display the priority of current Thread in C#

using System;
using System.Threading;
namespace Example
{
   class MyThreadClass
   {
       static void Main(string[] args)
       {
           Thread t = Thread.CurrentThread;
           t.Name = "First Thread";
           Console.WriteLine("Thread Name : {0}", t.Name);
           Console.WriteLine("Thread Priority : {0}", t.Priority);
           Console.ReadKey();
       }
   }
}

The above program generates the following output:

Thread Name : First Thread
Thread Priority : Normal

Pause the Thread for a specified period

Use the Sleep() method to pause the Thread for a specified period. Let us see the code now:

Source Code: Program to pause the Thread for a specified period in C#

using System;
using System.Threading;
namespace Example
{
   class MyThreadClass
   {
       static void Main(string[] args)
       {
           Thread t = Thread.CurrentThread;
           t.Name = "First Thread";
           Console.WriteLine("Thread Name : {0}", t.Name);
           Console.WriteLine("Thread Priority : {0}", t.Priority);
           Console.WriteLine("Child Thread Paused...");
           // using Sleep() method
           Thread.Sleep(1000);
           Console.WriteLine("Child Thread Resumed...");
           Console.ReadKey();
       }
   }
}

The above program generates the following output:

Thread Name : First Thread
Thread Priority : Normal
Child Thread Paused...
Child Thread Resumed...