How to Create Threads in C#?

Multithreading enables concurrent task execution in C#. It improves performance and responsiveness. We can create threads using the System.Threading namespace. With the help of Threads, we can achieve multitasking and can define their behavior using different methods provided by the Thread Class.

Example: This example shows how to create and start a thread using Thread Class in C#.

// C# Program to create and start a thread 
// using Thread Class
using System;
using System.Threading;

class Geeks
{
	static void Main()
	{
		// Create a new thread and start it
		Thread thread = new Thread(new ThreadStart(Worker));
		thread.Start();

		// Do some work in the main thread
		for (int i = 0; i < 3; i++)
		{
			Console.WriteLine("Main thread: {0}", i);
			Thread.Sleep(100);
		}

		// Wait for the worker thread to finish
		thread.Join();
	}

	static void Worker()
	{
		for (int i = 0; i < 3; i++)
		{
			Console.WriteLine("Worker thread: {0}", i);
			Thread.Sleep(100);
		}
	}
}

Main thread: 0
Worker thread: 0
Main thread: 1
Worker thread: 1
Main thread: 2
Worker thread: 2

Explanation: In this example, we create a new thread using the Thread class and pass in a delegate to the Worker method. We then start the thread using the Start method. Then we have used the join method to wait until the other thread completes it works.

Note: While creating thread make sure to properly synchronize access to shared data between threads to avoid race conditions and other synchronization issues.

Steps to Create a Thread

Step 1: importing System.Threading namespace

First, import the System.Threading namespace. It plays an important role in creating a thread in our program, as it allows us to use thread-related classes without specifying their fully qualified names every time.

using System;

using System.Threading;

Step 2: Creation and Initialization

Now, create and initialize the thread object in main method.

public static void main()
{
Thread thr = new Thread(job1);
}

Step 3: Starting the Thread

Start the thread using the Start method.

public static void main()

{
Thread thr = new Thread(job1);

thr.Start();
}

Example:

// C# program to illustrate the
// creation of thread using
// non-static method
using System;
using System.Threading;

public class ExThread
{

	// Non-static method
	public void mythread1()
	{
		for (int z = 0; z < 3; z++)
		{
			Console.WriteLine("First Thread");
		}
	}
}

class Geeks
{
	public static void Main()
	{
		// Creating object of ExThread class
		ExThread obj = new ExThread();

		// Creating thread
		// Using thread class
		Thread thr = new Thread(new ThreadStart(obj.mythread1));
		thr.Start();
	}
}

First Thread
First Thread
First Thread

Explanation: In the above example, we create an instance (obj) of the ExThread class and pass its method (mythread1) to the ThreadStart delegate. Then, we create a thread (thr) and start it using thr.Start() to execute the method in a separate thread.

Example:

// C# program to illustrate the creation
// of thread using static method
using System;
using System.Threading;

public class ExThread
{
	// Static method for thread a
	public static void thread1()
	{
		for (int i = 0; i < 3; i++)
			Console.WriteLine(i);
	}

	// static method for thread b
	public static void thread2()
	{
		for (int i = 0; i < 3; i++)
			Console.WriteLine(i);
		
	}
}

class Geeks
{
	public static void Main()
	{
		// Creating and initializing threads
		Thread a = new Thread(ExThread.thread1);
		Thread b = new Thread(ExThread.thread2);
		a.Start();
		b.Start();
	}
}

0
1
2
0
1
2

Explanation: In the above example, The ExThread contains two static methods thread1() and thread2(). So we do not need to create an instance of ExThread class. Here, we call these methods using a class name, we create and initialize the work of thread a, similarly for thread b. By using a.Start(); and b.Start(); statements, a and b threads scheduled for execution. 

Note: The output of these programs may vary due to context switching.

Different Ways to Create Threads

• Using Thread Class
• Using Task Class
• Using ThreadStart Delegate

1. Using Thread Class

In C# Thread Class is used to create and manage threads, providing greater control over multithreading. It allows operations such as setting thread priorities, managing thread states, and handling synchronization. We can perform multiple operations on threads, set thread priorities, manage thread states, and handle synchronization mechanisms to prevent race conditions.

Example:

// Create thread using Thread class
using System;
using System.Threading;

class Geeks
{
    static void Main()
    {
        // Creating a thread using Thread Class
        Thread thread = new Thread(() => {
            Console.WriteLine("Thread is running....");
        });
        
        thread.Start();
        thread.Join();
    }
}

Thread is running....

2. Using Task Class

In C# Task class is part of the Task Parallel Library (TPL) and is used for managing and running asynchronous operations or parallel tasks. It simplifies multithreading by abstracting the complexity of thread management and provides a more scalable and efficient way to handle concurrent operations.

Example:

// Create thread using Task Class
using System;
using System.Threading.Tasks;

class Geeks
{
    static void Main()
    {
        // Creating a Task
        Task task = Task.Run(() => {
            Console.WriteLine("Task is running......");
        });

        task.Wait();
    }
}

Task is running......

3. ThreadStart Delegate

The ThreadStart delegate in C# specifies the method to execute when a thread starts. It represents a method that takes no parameters and returns void. The delegate allows a method to be passed directly to the Thread constructor for execution in a separate thread. It simplifies creating and starting threads by allowing us to pass a method directly to the Thread constructor for execution on a separate thread.

Example:

// Create thread using ThreadStart Delegate
using System;
using System.Threading;

class Geeks
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Program start");

        // Create and start a new thread 
        // using ThreadStart delegate
        Thread newThread = new Thread(new ThreadStart(() =>
        {
            Console.WriteLine("Thread started..");

            // sleep for 100 milliseconds
            Thread.Sleep(100);

            Console.WriteLine("Thread finished..");
        }));
        newThread.Start();
    }

}

Program start
Thread started..
Thread finished..

Classes Used in Thread

In C#, a multi-threading system is built upon the Thread class, which encapsulates the execution of threads. This class contains several methods and properties which help in managing and creating threads and this class is defined under System.Threading namespace. The System.Threading namespace provides classes and interfaces that are used in multi-thread programming. Some commonly used classes in this namespace are: