C#多线程之基础篇2

　　在上一篇C#多线程之基础篇1中，我们主要讲述了如何创建线程、中止线程、线程等待以及终止线程的相关知识，在本篇中我们继续讲述有关线程的一些知识。

五、确定线程的状态

 　　在这一节中，我们将讲述如何查看一个线程的状态，通常知道一个线程处于什么状态是非常有用的。但是，要注意线程是独立运行的，它的状态可能随时变化。要查看一个线程的状态，我们可以按如下步骤进行：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，然后修改为如下代码：

using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;

namespace Recipe05
{
    class Program
    {
        static void DoNothing()
        {
            Sleep(TimeSpan.FromSeconds(2));
        }

        static void PrintNumbersWithStatus()
        {
            WriteLine("Starting...");
            WriteLine(CurrentThread.ThreadState.ToString());

            for(int i = 1; i < 10; i++)
            {
                Sleep(TimeSpan.FromSeconds(2));
                WriteLine(i);
            }
        }

        static void Main(string[] args)
        {
            WriteLine("Starting program...");

            Thread t1 = new Thread(PrintNumbersWithStatus);
            Thread t2 = new Thread(DoNothing);

            WriteLine(t1.ThreadState.ToString());

            t2.Start();
            t1.Start();

            for(int i = 1; i < 30; i++)
            {
                WriteLine(i.ToString() + " - " + t1.ThreadState.ToString());
            }

            Sleep(TimeSpan.FromSeconds(6));

            t1.Abort();

            WriteLine("A thread has been aborted");
            WriteLine(t1.ThreadState.ToString());
            WriteLine(t2.ThreadState.ToString());
        }
    }
}

3、运行该控制台应用程序，运行效果（每次运行效果可能不同）如下图所示：

　　在上述代码中，我们在“Main”方法中定义了两个不同的线程t1和t2，t1线程在执行过程中被终止，t2线程成功执行完毕。我们可以使用Thread对象的ThreadState属性获得某个线程的状态信息，ThreadState属性是C#枚举类型。

　　当程序执行到第34行代码处时，t1线程还没有执行，这个时候t1线程的状态为“ThreadState.Unstarted”。

　　当程序执行到第37行代码处时，t1线程开始执行，这个时候该线程的状态为“ThreadState.Running”。

　　当运行到第39~42行代码处时，主线程开始执行循环语句，持续打印出29条t1线程的状态，因为在“PrintNumbersWithStatus”方法中调用了“Thread.Sleep”方法，因此在执行主线程的循环的过程中，t1线程的状态在“ThreadState.Running”和“ThreadState.WaitSleepJoin”之间转换。

　　当程序执行到第44行代码处时，在主线程中调用了“Thread.Sleep”方法，在等待6秒期间，“PrintNumbersWithStatus”方法中的for循环代码不断执行，因此打印出1、2、3共三行数字。

　　当程序执行到第46行代码处时，我们调用了t1的“Abort”方法，从而t1线程被终止。

　　当程序执行到第49行代码处时，由于已经在t1线程上调用了“Abort”方法，因此，它的状态为“ThreadState.Aborted”或“ThreadState.AbortRequested”。

　　当程序执行到第50行代码处时，因为t2线程正常执行完毕，因此t2线程的状态为“ThreadState.Stopped”。

六、线程优先级

 　　在这一小节中，我们将讲述线程的优先级，线程的优先级确定了线程所能使用CPU时间的大小。我们按以下步骤来完成线程优先级的学习：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，修改代码如下所示：

using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;
using static System.Diagnostics.Process;

namespace Recipe06
{
    class ThreadSample
    {
        private bool isStopped = false;

        public void Stop()
        {
            isStopped = true;
        }

        public void CountNumbers()
        {
            long counter = 0;
            while (!isStopped)
            {
                counter++;
            }

            WriteLine($"{CurrentThread.Name} with {CurrentThread.Priority,10} priority has a count = {counter,15:N0}");
        }
    }

    class Program
    {
        static void RunThreads()
        {
            var sample = new ThreadSample();

            var threadOne = new Thread(sample.CountNumbers);
            threadOne.Name = "ThreadOne";

            var threadTwo = new Thread(sample.CountNumbers);
            threadTwo.Name = "ThreadTwo";

            threadOne.Priority = ThreadPriority.Highest;
            threadTwo.Priority = ThreadPriority.Lowest;

            threadOne.Start();
            threadTwo.Start();

            Sleep(TimeSpan.FromSeconds(2));
            sample.Stop();
        }

        static void Main(string[] args)
        {
            WriteLine($"Current thread priority: {CurrentThread.Priority}");
            WriteLine("Running on all cores available");

            RunThreads();

            Sleep(TimeSpan.FromSeconds(2));

            WriteLine("Running on a single core");
            GetCurrentProcess().ProcessorAffinity = new IntPtr(1);
            RunThreads();
        }
    }
}

3、运行该控制台应用程序，运行效果（每次运行效果可能不同）如下图所示：

　　在上述代码中，我们定义了两个不同的线程threadOne和threadTwo。threadOne线程具有最高的优先级“ThreadPriority.Highest”，threadTwo具有最低的优先级“ThreadPriority.Lowest”。

　　在程序执行到第57行代码处，如果我们的计算机是多核计算机，我们将在2秒内获得初始结果，并且具有最高优先级的threadOne线程要比具有最低优先级的threadTwo线程的迭代次数更多一些，但也不会相差太远。但是，如果我们的计算机是单核计算机，则结果大不相同。

　　为了模拟单核计算机，我们将ProcessorAffinity的值设置为1，现在这两个线程所迭代的次数将差异非常大，并且程序的执行时间远远大于2秒。这是因为CPU的计算机时间大部分给予了高优先级的线程，而低优先级的线程获得非常少的CPU时间。

七、前台线程和后台线程

　　在这一小节中，我们将讲述什么是前台线程和后台线程，并且讲述如何设置这个选项以影响程序的行为。我们按以下步骤来完成前台线程和后台线程的学习：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，修改代码如下所示：

using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;

namespace Recipe07
{
    class ThreadSample
    {
        private readonly int iterations;

        public ThreadSample(int iterations)
        {
            this.iterations = iterations;
        }

        public void CountNumbers()
        {
            for(int i = 0; i < iterations; i++)
            {
                Sleep(TimeSpan.FromSeconds(0.5));
                WriteLine($"{CurrentThread.Name} prints {i}");
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var sampleForeground = new ThreadSample(10);
            var sampleBackground = new ThreadSample(20);

            var threadOne = new Thread(sampleForeground.CountNumbers);
            threadOne.Name = "ForegroundThread";

            var threadTwo = new Thread(sampleBackground.CountNumbers);
            threadTwo.Name = "BackgroundThread";
            threadTwo.IsBackground = true;

            threadOne.Start();
            threadTwo.Start();
        }
    }
}

3、运行该控制台应用程序，运行效果（每次运行效果可能不同）如下图所示：

　　在上述代码中，我们定义了两个不同的线程threadOne和threadTwo。当我们创建一个线程时，该线程显示地是一个前台线程，比如threadOne。如果我们要将一个线程设置为后台线程，只需要将该线程的“IsBackground”属性设置为“true”即可，比如threadTwo。我们还配置了两个线程执行的循环次数不一样，threadOne线程所执行的循环次数为10次，threadTwo线程所执行的循环次数为20次，因此threadOne线程要比threadTwo线程早执行完毕。

　　从执行结果上来看，当threadOne线程执行完毕后，主程序也结束了，并且后台线程也被终止了，这就是前台线程和后台线程的区别：进程会等待所有的前台进程执行完毕后才结束，单不会等待后台进程执行完毕。

八、向线程传递参数

 　　在这一小节，我将讲述如何向一个线程传递参数，我们将使用不同的方法来完成这个工作，具体步骤如下所示：

1、使用Visual Studio 2015创建一个新的控制台应用程序。

2、双击打开“Program.cs”文件，修改代码如下所示：

using System;
using System.Threading;
using static System.Console;
using static System.Threading.Thread;

namespace Recipe08
{
    class ThreadSample
    {
        private readonly int iterations;

        public ThreadSample(int iterations)
        {
            this.iterations = iterations;
        }

        public void CountNumbers()
        {
            for(int i = 1; i <= iterations; i++)
            {
                Sleep(TimeSpan.FromSeconds(0.5));
                WriteLine($"{CurrentThread.Name} prints {i}");
            }
        }
    }

    class Program
    {
        static void Count(object iterations)
        {
            CountNumbers((int)iterations);
        }

        static void CountNumbers(int iterations)
        {
            for(int i = 1; i <= iterations; i++)
            {
                Sleep(TimeSpan.FromSeconds(0.5));
                WriteLine($"{CurrentThread.Name} prints {i}");
            }
        }

        static void PrintNumber(int number)
        {
            WriteLine(number);
        }

        static void Main(string[] args)
        {
            var sample = new ThreadSample(10);

            var threadOne = new Thread(sample.CountNumbers);
            threadOne.Name = "ThreadOne";
            threadOne.Start();
            threadOne.Join();

            WriteLine("--------------------------");

            var threadTwo = new Thread(Count);
            threadTwo.Name = "ThreadTwo";
            threadTwo.Start(8);
            threadTwo.Join();

            WriteLine("--------------------------");

            var threadThree = new Thread(() => CountNumbers(12));
            threadThree.Name = "ThreadThree";
            threadThree.Start();
            threadThree.Join();

            WriteLine("--------------------------");

            int i = 10;
            var threadFour = new Thread(() => PrintNumber(i));

            i = 20;
            var threadFive = new Thread(() => PrintNumber(i));

            threadFour.Start();
            threadFive.Start();
        }
    }
}

3、运行该控制台应用程序，运行效果如下图所示：

　　在第50~55行代码处，我们首先创建了一个ThreadSample类型的对象，并将数字10传递给了该类型的构造方法。然后我们将ThreadSample对象的“CountNumbers”方法传递给了线程threadOne的构造方法，“CountNumbers”方法将在线程threadOne中被执行，因此我们通过“CountNumbers”方法将数字10传递给了线程threadOne。

　　在第59~62行代码处，我们使用“Thread.Start”的重载方法将一个对象传递给线程threadTwo，要使该段代码正确运行，我们要保证在构造threadTwo线程时，传给给Thread的构造方法的委托要带有一个object类型的参数。在这段代码中，我们将8看作一个对象传递给“Count”方法，该方法有调用了同名的重载方法将object对象转换为整数类型。

　　在第66~69行代码处，我们在创建threadThree线程时，给Thread构造方法传递的是一个lambda表达式，该表达式定义了一个不属于任何类的方法，我们在该lambda表达式中调用了“CountNumbers”方法，并将12传递给了“CountNumbers”方法，通过lambda表达式，我们将12传递给了threadThree线程。

　　注意：当我们将一个局部变量用于多个lambda表达式时，这些lambda表达式将会共享这个变量的值，在第73~80行代码处，我们将局部变量用于了两个lambda表达式，我们运行threadFour和threadFive线程后，我们发现打印出来的结果都是20。

 　　未完待续！