Join, Sleep and Abort methods in C# Threading

The Thread class in C# provides several important methods to control thread execution: Join(), Sleep(), and Abort(). These methods allow you to synchronize threads, pause execution, and terminate threads when needed.

Syntax

Following is the syntax for the three main thread control methods −

// Join method
thread.Join();
thread.Join(timeout);

// Sleep method
Thread.Sleep(milliseconds);

// Abort method (obsolete in .NET Core/.NET 5+)
thread.Abort();

Join Method

The Join() method blocks the calling thread until the target thread terminates. This ensures that the calling thread waits for another thread to complete before continuing execution.

Example

using System;
using System.Threading;

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

   static void Main(string[] args) {
      Thread t = new Thread(Run);
      t.Start();
      Console.WriteLine("Main thread waiting for worker thread...");
      t.Join();
      Console.WriteLine("Worker thread completed. Main thread continues.");
   }
}

The output of the above code is −

Main thread waiting for worker thread...
Worker thread: 0
Worker thread: 1
Worker thread: 2
Worker thread completed. Main thread continues.

Sleep Method

The Sleep() method pauses the current thread for a specified number of milliseconds. This is useful for creating delays or yielding control to other threads.

Example

using System;
using System.Threading;

class SleepDemo {
   static void CountWithDelay() {
      for (int i = 1; i <= 5; i++) {
         Console.WriteLine("Count: " + i + " at " + DateTime.Now.ToString("HH:mm:ss"));
         Thread.Sleep(2000); // Sleep for 2 seconds
      }
   }

   static void Main(string[] args) {
      Console.WriteLine("Starting countdown with 2-second delays:");
      CountWithDelay();
      Console.WriteLine("Countdown completed!");
   }
}

The output of the above code is −

Starting countdown with 2-second delays:
Count: 1 at 14:30:15
Count: 2 at 14:30:17
Count: 3 at 14:30:19
Count: 4 at 14:30:21
Count: 5 at 14:30:23
Countdown completed!

Abort Method (Obsolete)

The Abort() method forcibly terminates a thread by throwing a ThreadAbortException. Note: This method is obsolete in .NET Core and .NET 5+ due to its unsafe nature and potential to cause resource leaks.

Example (Legacy .NET Framework)

using System;
using System.Threading;

class ThreadAbortDemo {
   public static void WorkerMethod() {
      try {
         Console.WriteLine("Worker thread started");
         for (int i = 0; i <= 10; i++) {
            Thread.Sleep(500);
            Console.WriteLine("Working: " + i);
         }
         Console.WriteLine("Worker thread completed normally");
      } catch (ThreadAbortException) {
         Console.WriteLine("Worker thread was aborted");
      } finally {
         Console.WriteLine("Cleanup in finally block");
      }
   }

   static void Main(string[] args) {
      Thread workerThread = new Thread(WorkerMethod);
      workerThread.Start();
      Thread.Sleep(2000);
      Console.WriteLine("Main thread aborting worker thread");
      workerThread.Abort();
      workerThread.Join();
      Console.WriteLine("Main thread finished");
   }
}

The output of the above code is −

Worker thread started
Working: 0
Working: 1
Working: 2
Working: 3
Main thread aborting worker thread
Worker thread was aborted
Cleanup in finally block
Main thread finished

Comparison of Thread Control Methods

Conclusion

The Join() and Sleep() methods are essential for thread control in C#, providing synchronization and timing capabilities. While Abort() exists in legacy .NET Framework, modern applications should use safer alternatives like cancellation tokens for thread termination.