It's multithreaded

C# multithreaded

Thread lifecycle

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

The various states in the thread life cycle are listed below:

• Unstilled state: The condition when a thread instance is created but the Start method is not called.
• Ready state: The condition when a thread is ready to run and waits for a CPU cycle.
• Non-operational: Threads are not operational in the following cases:
  • The Sleep method has been called
  • The Wait method has been called
  • Blocked by I/O operation
• Dead state: The condition when the thread has completed execution or has been aborted.

The main thread

In C#, the System.Threading.Thread class is used for thread work. I t allows you to create and access a single thread in a multithreaded application. The first thread executed in the process is called the main thread.

The main thread is automatically created when the C#program starts executing. T hreads created using the Thread class are called by the subthreads 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 produces the following results:

This is MainThread

Properties and methods commonly used by thread classes

The following table lists some common properties of the Thread class:

The following table lists some common methods of the Thread class:

Create a thread

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

Manage threads

The Thread class provides a variety of ways to manage threads.

The following example demonstrates the use of the sleep() method to pause threads 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 produces the following results:

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

Destroy the thread

The Abort() method is used to destroy threads.

Abort the thread at runtime by throwing threadabortexception. This exception cannot be caught, and if there is a final block, control is sent to the final block.

The following procedure illustrates this point:

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