C#多线程系列之线程的创建和生命周期

1，获取当前线程信息

Thread.CurrentThread 是一个 静态的 Thread 类，Thread 的CurrentThread 属性，可以获取到当前运行线程的一些信息，其定义如下：

public static System.Threading.Thread CurrentThread { get; }

Thread 类有很多属性和方法，这里就不列举了，后面的学习会慢慢熟悉更多 API 和深入了解使用。

这里有一个简单的示例：

        static void Main(string[] args)
        {
            Thread thread = new Thread(OneTest);
            thread.Name = "Test";
            thread.Start();
            Console.ReadKey();
        }

        public static void OneTest()
        {
            Thread thisTHread = Thread.CurrentThread;
            Console.WriteLine("线程标识：" + thisTHread.Name);
            Console.WriteLine("当前地域：" + thisTHread.CurrentCulture.Name);  // 当前地域
            Console.WriteLine("线程执行状态：" + thisTHread.IsAlive);
            Console.WriteLine("是否为后台线程：" + thisTHread.IsBackground);
            Console.WriteLine("是否为线程池线程"+thisTHread.IsThreadPoolThread);
        }

输出

线程标识：Test
当前地域：zh-CN
线程执行状态：True
是否为后台线程：False
是否为线程池线程False

2，管理线程状态

一般认为，线程有五种状态：

新建(new 对象) 、就绪(等待CPU调度)、运行(CPU正在运行)、阻塞(等待阻塞、同步阻塞等)、死亡(对象释放)。

理论的东西不说太多，直接撸代码。

2.1 启动与参数传递

新建线程简直滚瓜烂熟，无非 new 一下，然后 Start()。

Thread thread = new Thread(); 

Thread 的构造函数有四个：

public Thread(ParameterizedThreadStart start);

public Thread(ThreadStart start);

public Thread(ParameterizedThreadStart start, int maxStackSize);

public Thread(ThreadStart start, int maxStackSize);

我们以启动新的线程时传递参数来举例，使用这四个构造函数呢？

2.1.1 ParameterizedThreadStart

ParameterizedThreadStart 是一个委托，构造函数传递的参数为需要执行的方法，然后在 Start 方法中传递参数。

需要注意的是，传递的参数类型为 object，而且只能传递一个。

代码示例如下：

        static void Main(string[] args)
        {
            string myParam = "abcdef";
            ParameterizedThreadStart parameterized = new ParameterizedThreadStart(OneTest);
            Thread thread = new Thread(parameterized);
            thread.Start(myParam);
            Console.ReadKey();
        }

        public static void OneTest(object obj)
        {
            string str = obj as string;
            if (string.IsNullOrEmpty(str))
                return;

            Console.WriteLine("新的线程已经启动");
            Console.WriteLine(str);
        }

2.1.2 使用静态变量或类成员变量

此种方法不需要作为参数传递，各个线程共享堆栈。

优点是不需要装箱拆箱，多线程可以共享空间；缺点是变量是大家都可以访问，此种方式在多线程竞价时，可能会导致多种问题(可以加锁解决)。

下面使用两个变量实现数据传递：

    class Program
    {
        private string A = "成员变量";
        public static string B = "静态变量";

        static void Main(string[] args)
        {
            // 创建一个类
            Program p = new Program();

            Thread thread1 = new Thread(p.OneTest1);
            thread1.Name = "Test1";
            thread1.Start();

            Thread thread2 = new Thread(OneTest2);
            thread2.Name = "Test2";
            thread2.Start();

            Console.ReadKey();
        }

        public void OneTest1()
        {
            Console.WriteLine("新的线程已经启动");
            Console.WriteLine(A);       // 本身对象的其它成员
        }
        public static void OneTest2()
        {
            Console.WriteLine("新的线程已经启动");
            Console.WriteLine(B);       // 全局静态变量
        }
    }

2.1.3 委托与Lambda

原理是 Thread 的构造函数 public Thread(ThreadStart start);，ThreadStart 是一个委托，其定义如下

public delegate void ThreadStart();

使用委托的话，可以这样写

        static void Main(string[] args)
        {
            System.Threading.ThreadStart start = DelegateThread;

            Thread thread = new Thread(start);
            thread.Name = "Test";
            thread.Start();


            Console.ReadKey();
        }

        public static void DelegateThread()
        {
            OneTest("a", "b", 666, new Program());
        }
        public static void OneTest(string a, string b, int c, Program p)
        {
            Console.WriteLine("新的线程已经启动");
        }

有那么一点点麻烦，不过我们可以使用 Lambda 快速实现。

使用 Lambda 示例如下：

        static void Main(string[] args)
        {
            Thread thread = new Thread(() =>
            {
                OneTest("a", "b", 666, new Program());
            });
            thread.Name = "Test";
            thread.Start();
            
            Console.ReadKey();
        }

        public static void OneTest(string a, string b, int c, Program p)
        {
            Console.WriteLine("新的线程已经启动");
        }

提示：如果需要处理的算法比较简单的话，可以直接写进委托中，不需要另外写方法啦。

可以看到，C# 是多么的方便。

2.2 暂停与阻塞

Thread.Sleep() 方法可以将当前线程挂起一段时间，Thread.Join() 方法可以阻塞当前线程一直等待另一个线程运行至结束。

在等待线程 Sleep() 或 Join() 的过程中，线程是阻塞的(Blocket)。

    阻塞的定义：当线程由于特点原因暂停执行，那么它就是阻塞的。 
    如果线程处于阻塞状态，线程就会交出他的 CPU 时间片，并且不会消耗 CPU 时间，直至阻塞结束。 
    阻塞会发生上下文切换。

代码示例如下：

        static void Main(string[] args)
        {
            Thread thread = new Thread(OneTest);
            thread.Name = "小弟弟";

            Console.WriteLine($"{DateTime.Now}:大家在吃饭，吃完饭后要带小弟弟逛街");
            Console.WriteLine("吃完饭了");
            Console.WriteLine($"{DateTime.Now}:小弟弟开始玩游戏");
            thread.Start();

            // 化妆 5 s
            Console.WriteLine("不管他，大姐姐化妆先"); Thread.Sleep(TimeSpan.FromSeconds(5));

            Console.WriteLine($"{DateTime.Now}:化完妆，等小弟弟打完游戏");
            thread.Join();

            Console.WriteLine("打完游戏了嘛？" + (!thread.IsAlive ? "true" : "false"));
            Console.WriteLine($"{DateTime.Now}:走，逛街去");
            Console.ReadKey();
        }

        public static void OneTest()
        {
            Console.WriteLine(Thread.CurrentThread.Name + "开始打游戏");
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine($"{DateTime.Now}:第几局：" + i);
                Thread.Sleep(TimeSpan.FromSeconds(2));      // 休眠 2 秒
            }
            Console.WriteLine(Thread.CurrentThread.Name + "打完了");
        }

Join() 也可以实现简单的线程同步，即一个线程等待另一个线程完成。

2.3 线程状态

ThreadState 是一个枚举，记录了线程的状态，我们可以从中判断线程的生命周期和健康情况。

其枚举如下：

枚举	值	说明
Initialized	0	此状态指示线程已初始化但尚未启动。
Ready	1	此状态指示线程因无可用的处理器而等待使用处理器。 线程准备在下一个可用的处理器上运行。
Running	2	此状态指示线程当前正在使用处理器。
Standby	3	此状态指示线程将要使用处理器。 一次只能有一个线程处于此状态。
Terminated	4	此状态指示线程已完成执行并已退出。
Transition	6	此状态指示线程在可以执行前等待处理器之外的资源。 例如，它可能正在等待其执行堆栈从磁盘中分页。
Unknown	7	线程的状态未知。
Wait	5	此状态指示线程尚未准备好使用处理器，因为它正在等待外围操作完成或等待资源释放。 当线程就绪后，将对其进行重排。

但是里面有很多枚举类型是没有用处的，我们可以使用一个这样的方法来获取更加有用的信息：

        public static ThreadState GetThreadState(ThreadState ts)
        {
            return ts & (ThreadState.Unstarted |
                ThreadState.WaitSleepJoin |
                ThreadState.Stopped);
        }

根据 2.2 中的示例，我们修改一下 Main 中的方法：

        static void Main(string[] args)
        {
            Thread thread = new Thread(OneTest);
            thread.Name = "小弟弟";

            Console.WriteLine($"{DateTime.Now}:大家在吃饭，吃完饭后要带小弟弟逛街");
            Console.WriteLine("吃完饭了");
            Console.WriteLine($"{DateTime.Now}:小弟弟开始玩游戏");
            Console.WriteLine("弟弟在干嘛？(线程状态)：" + Enum.GetName(typeof(ThreadState), GetThreadState(thread.ThreadState)));
            thread.Start();
            Console.WriteLine("弟弟在干嘛？(线程状态)：" + Enum.GetName(typeof(ThreadState), GetThreadState(thread.ThreadState)));
            // 化妆 5 s
            Console.WriteLine("不管他，大姐姐化妆先"); Thread.Sleep(TimeSpan.FromSeconds(5));
            Console.WriteLine("弟弟在干嘛？(线程状态)：" + Enum.GetName(typeof(ThreadState), GetThreadState(thread.ThreadState)));
            Console.WriteLine($"{DateTime.Now}:化完妆，等小弟弟打完游戏");
            thread.Join();
            Console.WriteLine("弟弟在干嘛？(线程状态)：" + Enum.GetName(typeof(ThreadState), GetThreadState(thread.ThreadState)));
            Console.WriteLine("打完游戏了嘛？" + (!thread.IsAlive ? "true" : "false"));
            Console.WriteLine($"{DateTime.Now}:走，逛街去");
            Console.ReadKey();
        }

代码看着比较乱，请复制到项目中运行一下。

输出示例：

2020/4/11 11:01:48:大家在吃饭，吃完饭后要带小弟弟逛街
吃完饭了
2020/4/11 11:01:48:小弟弟开始玩游戏
弟弟在干嘛？(线程状态)：Unstarted
弟弟在干嘛？(线程状态)：Running
不管他，大姐姐化妆先
小弟弟开始打游戏
2020/4/11 11:01:48:第几局：0
2020/4/11 11:01:50:第几局：1
2020/4/11 11:01:52:第几局：2
弟弟在干嘛？(线程状态)：WaitSleepJoin
2020/4/11 11:01:53:化完妆，等小弟弟打完游戏
2020/4/11 11:01:54:第几局：3
2020/4/11 11:01:56:第几局：4
2020/4/11 11:01:58:第几局：5
2020/4/11 11:02:00:第几局：6
2020/4/11 11:02:02:第几局：7
2020/4/11 11:02:04:第几局：8
2020/4/11 11:02:06:第几局：9
小弟弟打完了
弟弟在干嘛？(线程状态)：Stopped
打完游戏了嘛？true
2020/4/11 11:02:08:走，逛街去

可以看到 Unstarted、WaitSleepJoin、Running、Stopped四种状态，即未开始（就绪）、阻塞、运行中、死亡。

2.4 终止

.Abort() 方法不能在 .NET Core 上使用，不然会出现 System.PlatformNotSupportedException:“Thread abort is not supported on this platform.” 。

后面关于异步的文章会讲解如何实现终止。

由于 .NET Core 不支持，就不理会这两个方法了。这里只列出 API，不做示例。

方法	说明
Abort()	在调用此方法的线程上引发 ThreadAbortException，以开始终止此线程的过程。 调用此方法通常会终止线程。
Abort(Object)	引发在其上调用的线程中的 ThreadAbortException以开始处理终止线程，同时提供有关线程终止的异常信息。 调用此方法通常会终止线程。

Abort() 方法给线程注入 ThreadAbortException 异常，导致程序被终止。但是不一定可以终止线程。

2.5 线程的不确定性

线程的不确定性是指几个并行运行的线程，不确定在下一刻 CPU 时间片会分配给谁(当然，分配有优先级)。

对我们来说，多线程是同时运行的，但一般 CPU 没有那么多核，不可能在同一时刻执行所有的线程。CPU 会决定某个时刻将时间片分配给多个线程中的一个线程，这就出现了 CPU 的时间片分配调度。

执行下面的代码示例，你可以看到，两个线程打印的顺序是不确定的，而且每次运行结果都不同。

CPU 有一套公式确定下一次时间片分配给谁，但是比较复杂，需要学习计算机组成原理和操作系统。

留着下次写文章再讲。

        static void Main(string[] args)
        {
            Thread thread1 = new Thread(Test1);
            Thread thread2 = new Thread(Test2);

            thread1.Start();
            thread2.Start();

            Console.ReadKey();
        }

        public static void Test1()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("Test1:" + i);
            }
        }
        public static void Test2()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("Test2:" + i);
            }
        }

2.6 线程优先级、前台线程和后台线程

Thread.Priority 属性用于设置线程的优先级，Priority 是一个 ThreadPriority 枚举，其枚举类型如下

枚举	值	说明
AboveNormal	3	可以将 安排在具有 Highest 优先级的线程之后，在具有 Normal 优先级的线程之前。
BelowNormal	1	可以将 Thread 安排在具有 Normal 优先级的线程之后，在具有 Lowest 优先级的线程之前。
Highest	4	可以将 Thread 安排在具有任何其他优先级的线程之前。
Lowest	0	可以将 Thread 安排在具有任何其他优先级的线程之后。
Normal	2	可以将 Thread 安排在具有 AboveNormal 优先级的线程之后，在具有 BelowNormal 优先级的线程之前。 默认情况下，线程具有 Normal 优先级。

优先级排序：Highest > AboveNormal > Normal > BelowNormal > Lowest。

Thread.IsBackgroundThread 可以设置线程是否为后台线程。

前台线程的优先级大于后台线程，并且程序需要等待所有前台线程执行完毕后才能关闭；而当程序关闭是，无论后台线程是否在执行，都会强制退出。

2.7 自旋和休眠

当线程处于进入休眠状态或解除休眠状态时，会发生上下文切换，这就带来了昂贵的消耗。

而线程不断运行，就会消耗 CPU 时间，占用 CPU 资源。

对于过短的等待，应该使用自旋(spin)方法，避免发生上下文切换；过长的等待应该使线程休眠，避免占用大量 CPU 时间。

我们可以使用最为熟知的 Sleep() 方法休眠线程。有很多同步线程的类型，也使用了休眠手段等待线程（已经写好草稿啦）。

自旋的意思是，没事找事做。

例如：

        public static void Test(int n)
        {
            int num = 0;
            for (int i=0;i<n;i++)
            {
                num += 1;
            }
        }

通过做一些简单的运算，来消耗时间，从而达到等待的目的。

C# 中有关于自旋的自旋锁和 Thread.SpinWait(); 方法，在后面的线程同步分类中会说到自旋锁。

Thread.SpinWait() 在极少数情况下，避免线程使用上下文切换很有用。其定义如下

public static void SpinWait(int iterations);

SpinWait 实质上是（处理器）使用了非常紧密的循环，并使用 iterations 参数指定的循环计数。 SpinWait 等待时间取决于处理器的速度。

SpinWait 无法使你准确控制等待时间，主要是使用一些锁时用到，例如 Monitor.Enter。

到此这篇关于C#多线程系列之线程的创建和生命周期的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持猪先飞。