Multithreading In C# .NET

In this blog, you will learn about multithreading in C# .NET.

Introduction

If you have a program which executes from top to bottom, it would not be responsive and feasible to build complex Applications. Thus, .NET framework offers some classes to create complex Applications.

What is threading?

In short, thread is like a virtualized CPU, which helps to develop complex Applications.

Understanding threading

Suppose, you have a computer, which has only one CPU, which is capable of executing only one operation at a time and your Application has a complex operation. Thus, in this situation, your Application will take too much time. This means that the whole machine would freeze and appear unresponsive. Thus, your Application performance will decrease.

Thus, for this purpose, we will be using multithreading in C#.NET. Thus, we will divide our program into the different parts, using threading. You know, every Application runs its own process in Windows. Thus, every process will run in its own thread.

Thread Class

Thread class can be found in System.Threading namespace. Using this class, you can create a new thread and can manage your programs like property, status etc. of your thread.

Example

The following code shows how to create a thread in C#.NET

class Program
    {
        private static void loopTask()
        {
            for(int x = 0; x<10; x++)
            {
                Console.WriteLine("X => {0}", x);
                Thread.Sleep(1000);
            }
        }

        static void Main(string[] args)
        {
            ThreadStart thread = new ThreadStart(loopTask);
            Thread myThread = new Thread(thread);

            myThread.Start();

            for (int y = 0; y < 4; y++)
            {
                Console.WriteLine("Main thread.");
                Thread.Sleep(1000);
            }

            Console.ReadKey();
        }

Explanation:

You may observe this. I create a new Local Variable thread of ThreadStart delegate and pass the loopTask as a parameter to execute it. This loopTask function has a loop. We create a new object myThread from Thread Class and pass Local Variable thread to the Thread Constructor. Start the thread, using myThread.Start(); and Thread.Sleep(2000); will pause the current for 2000 milliseconds.

Finally, the result will be:



This code can also be written in a more simple way like:

class Program
    {
        static void Main(string[] args)
        {
            new Thread(new ThreadStart(() => {
                for (int x = 0; x < 10; x++)
                {
                    Console.WriteLine("X => {0}", x);
                    Thread.Sleep(1000);
                }
            })).Start();

            Console.ReadKey();
        }
    }

In the code, given above, we are using lambda expression ( => ) for the initialization. 

Passing Value as Parameter

The Thread constructor has another overload, which takes an instance of a ParameterizedThreadStart delegate. It can be used, if you want to pass some data through the start method of your thread to your method.

class Program
    {
        private static void loopTask(object value)
        {
            for(int x = 0; x<10; x++)
            {
                Console.WriteLine("X => {0} And Parameter Value is => {1}", x, value);
                Thread.Sleep(1000);
            }
        }

        static void Main(string[] args)
        {
            Thread myThread = new Thread( new ParameterizedThreadStart(loopTask));

            myThread.Start("Kashif");

            Console.ReadKey();
        }
    }

In this case, the value 5 is passed to the loopTask as an object. You can cast it to the expected type. 

How to stop/abort a thread?

To stop the thread, what we use is Thread.Abort method. This method can be executed by other threads at any time. When Thread.Abort is executed, it throws an exception ThreadAbortException.

Example

class Program
    {
        private static void loopTask()
        {
            try
            {
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine(i);
                    Thread.Sleep(1000);
                }
            }
            catch (ThreadAbortException e)
            {
                Console.WriteLine(e.Message);
            }
        }
        static void Main(string[] args)
        {
            Thread t = new Thread(new ThreadStart(loopTask));
            t.Start();
            Thread.Sleep(2000);
            t.Abort();
            Console.ReadKey();

        }
    }

Thanks for reading. :)