C# multithreading

Thread life cycle

The thread life cycle begins when an object of the System.Threading.Thread class is created and ends when the thread is terminated or completes execution.

The following lists the various states in the thread life cycle:

• Unstarted state: When the thread instance is created but the Start method has not The condition when called.

• Ready state: The condition when a thread is ready to run and waiting for CPU cycles.

• Unrunnable state: The thread is not runnable in the following situations:

  
  

• Sleep method has been called

• Wait method has been called

• Blocked by I/O operation

• Death state: The situation when the thread has completed execution or has been terminated.

Main thread

In C#, the System.Threading.Thread class is used for the work of threads. It allows the creation and access of individual threads in multi-threaded applications. The first thread to be executed in the process is called main thread.

When the C# program starts executing, the main thread is automatically created. Threads created using the Thread class are called by child threads of the main thread. You can access threads using the CurrentThread property of the Thread class.

The following program demonstrates the execution of the main thread:

using System;
using System.Threading;

namespace MultithreadingApplication
{
    class MainThreadProgram
    {
        static void Main(string[] args)
        {
            Thread th = Thread.CurrentThread;
            th.Name = "MainThread";
            Console.WriteLine("This is {0}", th.Name);
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it will produce the following results:

This is MainThread

Thread class commonly used Properties and methods

The following table lists some commonly used properties of the Thread class:

The following table lists some commonly used methods of the Thread class:

Creating threads

Threads are created by extending the Thread class. The extended Thread class calls the Start() method to start the execution of the child thread.

The following program demonstrates this concept:

using System;
using System.Threading;

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
        }
        
        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();
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following results:

In Main: Creating the Child thread
Child thread starts

Managing threads

The Thread class provides various methods for managing threads.

The following example demonstrates the use of the sleep() method, which is used to pause the thread at a specific time.

using System;
using System.Threading;

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            Console.WriteLine("Child thread starts");
            // 线程暂停 5000 毫秒
            int sleepfor = 5000; 
            Console.WriteLine("Child Thread Paused for {0} seconds", 
                              sleepfor / 1000);
            Thread.Sleep(sleepfor);
            Console.WriteLine("Child thread resumes");
        }
        
        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();
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it will produce the following results:

In Main: Creating the Child thread
Child thread starts
Child Thread Paused for 5 seconds
Child thread resumes

Destroy the thread

Abort() method is used Destroy the thread.

Abort a thread at runtime by throwing threadabortexception. This exception cannot be caught. If there is a finally block, control will be sent to the finally block.

The following program illustrates this:

using System;
using System.Threading;

namespace MultithreadingApplication
{
    class ThreadCreationProgram
    {
        public static void CallToChildThread()
        {
            try
            {

                Console.WriteLine("Child thread starts");
                // 计数到 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");
            }
            finally
            {
                Console.WriteLine("Couldn't catch the Thread Exception");
            }

        }
        
        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();
            // 停止主线程一段时间
            Thread.Sleep(2000);
            // 现在中止子线程
            Console.WriteLine("In Main: Aborting the Child thread");
            childThread.Abort();
            Console.ReadKey();
        }
    }
}

When the above code is compiled and executed, it produces the following results:

In Main: Creating the Child thread
Child thread starts
0
1
2
In Main: Aborting the Child thread
Thread Abort Exception
Couldn't catch the Thread Exception