How to Terminate a Thread in C#?

Last Updated : 20 Apr, 2026

In C#, threads are used to achieve tasks concurrently, a fundamental feature in multithreading and parallel programming. However, there are scenarios where we need to terminate a thread. There are different ways to terminate a thread and in this article, we will discuss those ways with their code implementation.

Ways to Terminate Thread

  • Abort Method
  • Abort Object
  • CancellationToken
  • Manually

1. Using Abort Method

The Abort() method throws a ThreadAbortException to the thread in which it is called, forcing the thread to terminate. However, this method is deprecated due to unpredictable behavior and is no longer recommended for use in modern versions of .NET.

Syntax:

public void Abort();

Exceptions:

  • SecurityException: If the caller does not have the required permission.
  • ThreadStateException: If the thread that is being aborted is currently suspended.

Example:

C# 
using System;
using System.Threading;

class ExampleofThread
{
	// Non-Static method
	public void thread()
	{
		for (int x = 0; x < 3; x++)
		{
			Console.WriteLine(x);
		}
	}
}

class Geeks
{
	public static void Main()
	{
		// Creating instance for mythread() method
		ExampleofThread o = new ExampleofThread();

		// Creating and initializing threads
		Thread thr = new Thread(new ThreadStart(o.thread));
		thr.Start();

		Console.WriteLine("Thread is abort");

		// Abort the thread
		// Using Abort() method
		thr.Abort();
	}
}

Output:

SecruityExceptionAndWarningAbortMeth

Explanation: The above example shows the use of the Abort() method which is provided by the Thread class. By using thr.Abort(); statement, we can terminate the execution of the thread.

Note: This method is deprecated and is no longer used in newer versions of .NET. Instead of using Abort(), prefer safer alternatives like CancellationToken.

2. Using Abort Object

This method raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread while also providing exception information about the thread termination. Same as Abort method this is also not recommended to use.

Syntax:

public void Abort(object information);

Here, the information contains any information that you want to pass in a thread when it is being stopped. This information is only accessible by using the ExceptionState property of ThreadAbortException. 

Exceptions:

  • SecurityException: If the caller does not have the required permission.
  • ThreadStateException: If the thread that is being aborted is currently suspended.

Example:

C# 
using System;
using System.Threading;

class ExThread
{
	public Thread thr;

	public ExThread(string name)
	{
		thr = new Thread(this.RunThread);
		thr.Name = name;
		thr.Start();
	}
	void RunThread()
	{
		try
		{
			Console.WriteLine(thr.Name +
						" is starting.");

			for (int j = 1; j < 10; j++)
			{
				Console.Write(j + " ");
				if ((j % 2) == 0)
				{
					Console.WriteLine();
					Thread.Sleep(100);
				}
			}
			Console.WriteLine(thr.Name +
				" exiting normally.");
		}
		catch (ThreadAbortException ex)
		{
			Console.WriteLine("Thread is aborted and the code is "
			+ ex.ExceptionState);
		}
	}
}

class Geeks
{
	static void Main()
	{

		// Creating object of ExThread
		ExThread obj = new ExThread("Thread ");
		Thread.Sleep(1000);
		Console.WriteLine("Stop thread");
		obj.thr.Abort(100);

		// Waiting for a thread to terminate.
		obj.thr.Join();
		Console.WriteLine("Main thread is terminating");
	}
}

Output:

AbortObjectExceptionWithWarning

Note:Abort(Object) is also not in used in newer versions and if we try to to execute the above program it will give the warning as shown in the output picture.

3. Using CancellationToken

CancellationToken allows us to politely request that a thread should stop its work. It is recommended to use in newer versions. We need to create a CancellationTokenSource object and pass its token to the thread.

Syntax

CancellationTokenSource tokenSource = new CancellationTokenSource(); // create object

Thread workerThread = new Thread(() => LongRunningOperation(tokenSource.Token));

if (token.IsCancellationRequested)

{

// Perform cleanup and exit

return;

}

tokenSource.Cancel();

Example:

C# 
using System;
using System.Threading;

public class ThreadWorker
{
    public void DoWork(CancellationToken ct)
    {
        for (int i = 0; i < 3; i++)
        {
            if (ct.IsCancellationRequested)
            {
                Console.WriteLine("Cancellation requested.");
                return;
            }

            Console.WriteLine($"Working... Step {i + 1}");
            Thread.Sleep(100);
        }

        Console.WriteLine("Work completed.");
    }
}

public class Geeks
{
    public static void Main()
    {
        CancellationTokenSource Cts = new CancellationTokenSource();
        CancellationToken ct = Cts.Token;

        Thread thr = new Thread(() => new ThreadWorker().DoWork(ct));
        thr.Start();

        Thread.Sleep(250); // allow some steps to run

        Cts.Cancel();

        thr.Join();

        Console.WriteLine("Main thread exits.");
    }
}

Output
Working... Step 1
Working... Step 2
Working... Step 3
Work completed.
Main thread exits.

4. Manual Termination

We can also terminate a thread manually just like creating a flag that the thread checks regularly to see if it should stop. This is a manual and simple method, but it requires the thread to periodically check the flag and decide when to exit.

Syntax

private volatile bool stopRequested; // Flag to signal thread termination

public void DoWork()

{

while (!stopRequested) // Check flag periodically

{
// Thread work here

Console.WriteLine("Working...");

Thread.Sleep(100); // Simulate work
}

}

public void RequestStop() => stopRequested = true;

Example:

C# 
using System;
using System.Threading;

public class ThreadWorker
{
    private bool stopRequested = false;

    public void DoWork()
    {
        for (int i = 0; i < 3; i++)
        {
            if (stopRequested)
            {
                Console.WriteLine("Stop requested, terminating the thread.");
                return; 
            }

            Console.WriteLine($"Working... Step {i + 1}");
            Thread.Sleep(100); 
        }

        Console.WriteLine("Work completed.");
    }

    public void RequestStop()
    {
        stopRequested = true;
    }
}

public class Geeks
{
    public static void Main()
    {
        ThreadWorker wrk = new ThreadWorker();
        Thread wrkThread = new Thread(wrk.DoWork);
        wrkThread.Start();

        // Simulate some work 
        Thread.Sleep(200);  

        // Request the wrk thread to stop
        wrk.RequestStop();

        // Wait for the wrk thread to finish
        wrkThread.Join();

        Console.WriteLine("Main thread exits.");
    }
}

Output
Working... Step 1
Working... Step 2
Stop requested, terminating the thread.
Main thread exits.

Key Points about Abort()

  • Calling Abort() can cause a deadlock if the thread holds a lock required by another thread.
  • If Abort() is called before Start(), the thread will abort when it starts; if called during sleep or blocking, the thread is interrupted and then aborted; if called on a suspended thread, it throws a ThreadStateException.
  • ThreadAbortException is thrown only when the thread returns to managed code and is delayed if the thread is suspended or executing unmanaged code.
  • Multiple calls to Abort() may behave unpredictably, and this situation cannot be detected by the application.
  • After calling Abort(), the thread state becomes AbortRequested, and after termination, it changes to Stopped, but it can be cancelled using ResetAbort() if allowed.
Comment

Explore