Abort in C#

The Thread.Abort() method in C# is used to forcibly terminate a thread by throwing a ThreadAbortException. This method was commonly used in older versions of .NET Framework but is now deprecated and not supported in .NET Core and .NET 5+.

Important Note: Thread.Abort() is considered unsafe and unreliable. Modern C# applications should use cooperative cancellation with CancellationToken instead.

Syntax

Following is the syntax for using Thread.Abort() −

thread.Abort();

The method throws a ThreadAbortException that can be caught, but the thread will still terminate −

try {
   // thread work
} catch (ThreadAbortException) {
   // cleanup code
} finally {
   // always executes
}

How Thread.Abort() Works

When Abort() is called, the runtime injects a ThreadAbortException into the target thread at the next safe point. The exception cannot be completely suppressed — even if caught, the thread will still terminate after executing any finally blocks.

Using Thread.Abort() (Legacy Example)

Example

using System;
using System.Threading;

class ThreadCreationProgram {
   public static void CallToChildThread() {
      try {
         Console.WriteLine("Child thread starts");
         
         // do some work, counting to 10
         for (int counter = 0; counter <= 10; counter++) {
            Thread.Sleep(500);
            Console.WriteLine(counter);
         }
         
         Console.WriteLine("Child Thread Completed");
      } catch (ThreadAbortException e) {
         Console.WriteLine("Thread Abort Exception caught");
      } finally {
         Console.WriteLine("Finally block executed - thread will terminate");
      }
   }

   static void Main(string[] args) {
      ThreadStart childref = new ThreadStart(CallToChildThread);
      Console.WriteLine("In Main: Creating the Child thread");

      Thread childThread = new Thread(childref);
      childThread.Start();

      // stop the main thread for some time
      Thread.Sleep(3000);

      // now abort the child
      Console.WriteLine("In Main: Aborting the Child thread");
      childThread.Abort();
      
      // wait for child thread to finish
      childThread.Join();
      Console.WriteLine("Main thread finished");
   }
}

The output of the above code is −

In Main: Creating the Child thread
Child thread starts
0
1
2
3
4
In Main: Aborting the Child thread
Thread Abort Exception caught
Finally block executed - thread will terminate
Main thread finished

Modern Alternative: CancellationToken

Example

using System;
using System.Threading;
using System.Threading.Tasks;

class ModernThreadCancellation {
   public static void DoWork(CancellationToken token) {
      try {
         Console.WriteLine("Worker thread starts");
         
         for (int counter = 0; counter <= 10; counter++) {
            // Check if cancellation was requested
            token.ThrowIfCancellationRequested();
            
            Thread.Sleep(500);
            Console.WriteLine(counter);
         }
         
         Console.WriteLine("Worker thread completed");
      } catch (OperationCanceledException) {
         Console.WriteLine("Worker thread was cancelled");
      }
   }

   static void Main(string[] args) {
      CancellationTokenSource cts = new CancellationTokenSource();
      
      Task workerTask = Task.Run(() => DoWork(cts.Token));
      
      // Cancel after 3 seconds
      Thread.Sleep(3000);
      Console.WriteLine("Requesting cancellation...");
      cts.Cancel();
      
      workerTask.Wait();
      Console.WriteLine("Main thread finished");
   }
}

The output of the above code is −

Worker thread starts
0
1
2
3
4
Requesting cancellation...
Worker thread was cancelled
Main thread finished

Comparison: Thread.Abort() vs CancellationToken

Conclusion

Thread.Abort() forcibly terminates threads by throwing ThreadAbortException, but it's deprecated due to safety concerns. Modern C# applications should use CancellationToken for cooperative thread cancellation, which is safer and more predictable than the abrupt termination caused by Abort().