Working with Threading in C#

Understanding the Thread States in the .Net

With the .NET Framework, you can easily write applications that perform multiple tasks simultaneously. Tasks with the potential of holding up other tasks can execute on separate threads, a process known as multithreading or free threading. Applications that use multithreading are more responsive to user input because the user interface stays active while processor-intensive tasks execute on separate threads. Multithreading is also useful when creating scalable applications, because you can add threads as the workload increases.

 class ThreadStateExample {
  static void Main() {
    Thread t = new Thread (delegate() { while (true); });
    Console.WriteLine (t.ThreadState);     // Unstarted
 
    t.Start();
    Thread.Sleep (1000);
    Console.WriteLine (t.ThreadState);     // Running
 
    t.Abort();
    Console.WriteLine (t.ThreadState);     // AbortRequested
 
    t.Join();
    Console.WriteLine (t.ThreadState);     // Stopped
  }
}

Creating threads in C#

The Thread class that belongs to the System.Threading namespace contains the necessary members for creating, suspending, resuming and aborting threads.

using System;
using System.Threading;
 
class Test
{
  static void MyThreadMethod()
  {
    Console.WriteLine("This is the workerthread.");
  }
 
  static void Main()
  {
    Console.WriteLine("This is the main orthe primary thread of the application.");

    Thread t = new Thread(newThreadStart(MyThreadMethod));

    t.Start();
     
  }
}

When the thread object is first created it is in the Unstarted state.  The Start() method is responsible for starting the thread.  Remember that when we start a thread it might not be immediately started. To be specific, it is actually put in the ready or the runnable state. It is the responsibility of the Operating System to actually schedule the thread from the runnable state to the running state. The method MyThreadMethod() contains the actual thread code that would be executed once a call to the Start() method is made.  It should be remembered that the following should hold good for a method to be a thread method.

• It should have no parameters.
• It should have a void return type.

Synchronization in Threads

Join() method is a synchronization method that blocks the calling thread (that is, the thread that calls the method) until the thread whose Join method is called has completed. Use this method to ensure that a thread has been terminated. The caller will block indefinitely if the thread does not terminate. In the following example, the Thread1 thread calls the Join() method of Thread2, which causes Thread1 to block until Thread2 has completed.

using System;
using System.Threading;

public class Example
{
   static Thread thread1, thread2;

   public static void Main()
   {
      thread1 = new Thread(ThreadProc);
      thread1.Name = "Thread1";
      thread1.Start();

      thread2 = new Thread(ThreadProc);
      thread2.Name = "Thread2";
      thread2.Start();  
   }

   private static void ThreadProc()
   {
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      if (Thread.CurrentThread.Name == "Thread1" &&
          thread2.ThreadState != ThreadState.Unstarted)
         thread2.Join();

      Thread.Sleep(4000);
      Console.WriteLine("\nCurrent thread: {0}", Thread.CurrentThread.Name);
      Console.WriteLine("Thread1: {0}", thread1.ThreadState);
      Console.WriteLine("Thread2: {0}\n", thread2.ThreadState);
   }
}
// The example displays output like the following:
//       Current thread: Thread1
//      
//       Current thread: Thread2
//      
//       Current thread: Thread2
//       Thread1: WaitSleepJoin
//       Thread2: Running
//      
//      
//       Current thread: Thread1
//       Thread1: Running
//       Thread2: Stopped

If the thread has already terminated when Join is called, the method returns immediately.