C#教程之C#多线程编程系列（二）- 线程基础

C#多线程编程系列（二）- 线程基础

---

1.1 简介#

线程基础主要包括线程创建、挂起、等待和终止线程。关于更多的线程的底层实现，CPU时间片轮转等等的知识，可以参考《深入理解计算机系统》一书中关于进程和线程的章节，本文不过多赘述。

1.2 创建线程#

在C#语言中，创建线程是一件非常简单的事情；它只需要用到 System.Threading命名空间，其中主要使用Thread类来创建线程。

演示代码如下所示：

Copy

using System; using System.Threading; // 创建线程需要用到的命名空间 namespace Recipe1 { class Program { static void Main(string[] args) { // 1.创建一个线程 PrintNumbers为该线程所需要执行的方法 Thread t = new Thread(PrintNumbers); // 2.启动线程 t.Start(); // 主线程也运行PrintNumbers方法，方便对照 PrintNumbers(); // 暂停一下 Console.ReadKey(); } static void PrintNumbers() { // 使用Thread.CurrentThread.ManagedThreadId 可以获取当前运行线程的唯一标识，通过它来区别线程 Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印..."); for (int i = 0; i < 10; i++) { Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i}"); } } } }

运行结果如下图所示，我们可以通过运行结果得知上面的代码创建了一个线程，然后主线程和创建的线程交叉输出结果，这说明PrintNumbers方法同时运行在主线程和另外一个线程中。

1.3 暂停线程#

暂停线程这里使用的方式是通过Thread.Sleep方法，如果线程执行Thread.Sleep方法，那么操作系统将在指定的时间内不为该线程分配任何时间片。如果Sleep时间100ms那么操作系统将至少让该线程睡眠100ms或者更长时间，所以Thread.Sleep方法不能作为高精度的计时器使用。

演示代码如下所示：

Copy

using System; using System.Threading; // 创建线程需要用到的命名空间 namespace Recipe2 { class Program { static void Main(string[] args) { // 1.创建一个线程 PrintNumbers为该线程所需要执行的方法 Thread t = new Thread(PrintNumbersWithDelay); // 2.启动线程 t.Start(); // 暂停一下 Console.ReadKey(); } static void PrintNumbersWithDelay() { Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印... 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}"); for (int i = 0; i < 10; i++) { //3. 使用Thread.Sleep方法来使当前线程睡眠，TimeSpan.FromSeconds(2)表示时间为 2秒 Thread.Sleep(TimeSpan.FromSeconds(2)); Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i} 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}"); } } } }

运行结果如下图所示，通过下图可以确定上面的代码是有效的，通过Thread.Sleep方法，使线程休眠了2秒左右，但是并不是特别精确的2秒。验证了上面的说法，它的睡眠是至少让线程睡眠多长时间，而不是一定多长时间。

1.4 线程等待#

在本章中，线程等待使用的是Join方法，该方法将暂停执行当前线程，直到所等待的另一个线程终止。在简单的线程同步中会使用到，但它比较简单，不作过多介绍。

演示代码如下所示：

Copy

class Program { static void Main(string[] args) { Console.WriteLine($"-------开始执行 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------"); // 1.创建一个线程 PrintNumbersWithDelay为该线程所需要执行的方法 Thread t = new Thread(PrintNumbersWithDelay); // 2.启动线程 t.Start(); // 3.等待线程结束 t.Join(); Console.WriteLine($"-------执行完毕 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------"); // 暂停一下 Console.ReadKey(); } static void PrintNumbersWithDelay() { Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印... 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}"); for (int i = 0; i < 10; i++) { Thread.Sleep(TimeSpan.FromSeconds(2)); Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i} 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}"); } } }

运行结果如下图所示，开始执行和执行完毕两条信息由主线程打印；根据其输出的顺序可见主线程是等待另外的线程结束后才输出执行完毕这条信息。

1.5 终止线程#

终止线程使用的方法是Abort方法，当该方法被执行时，将尝试销毁该线程。通过引发ThreadAbortException异常使线程被销毁。但一般不推荐使用该方法，原因有以下几点。

1. 使用Abort方法只是尝试销毁该线程，但不一定能终止线程。
2. 如果被终止的线程在执行lock内的代码，那么终止线程会造成线程不安全。
3. 线程终止时，CLR会保证自己内部的数据结构不会损坏，但是BCL不能保证。

基于以上原因不推荐使用Abort方法，在实际项目中一般使用CancellationToken来终止线程。

演示代码如下所示：

Copy

static void Main(string[] args) { Console.WriteLine($"-------开始执行 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------"); // 1.创建一个线程 PrintNumbersWithDelay为该线程所需要执行的方法 Thread t = new Thread(PrintNumbersWithDelay); // 2.启动线程 t.Start(); // 3.主线程休眠6秒 Thread.Sleep(TimeSpan.FromSeconds(6)); // 4.终止线程 t.Abort(); Console.WriteLine($"-------执行完毕 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}-------"); // 暂停一下 Console.ReadKey(); } static void PrintNumbersWithDelay() { Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 开始打印... 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}"); for (int i = 0; i < 10; i++) { Thread.Sleep(TimeSpan.FromSeconds(2)); Console.WriteLine($"线程：{Thread.CurrentThread.ManagedThreadId} 打印:{i} 现在时间{DateTime.Now.ToString("HH:mm:ss.ffff")}"); } }

运行结果如下图所示，启动所创建的线程3后，6秒钟主线程调用了Abort方法，线程3没有继续执行便结束了；与预期的结果一致。

1.6 检测线程状态#

线程的状态可通过访问ThreadState属性来检测，ThreadState是一个枚举类型，一共有10种状态，状态具体含义如下表所示。

成员名称	说明
Aborted	线程处于 Stopped 状态中。
AbortRequested	已对线程调用了 Thread.Abort 方法，但线程尚未收到试图终止它的挂起的 System.Threading.ThreadAbortException。
Background	线程正作为后台线程执行（相对于前台线程而言）。此状态可以通过设置 Thread.IsBackground 属性来控制。
Running	线程已启动，它未被阻塞，并且没有挂起的 ThreadAbortException。
Stopped	线程已停止。
StopRequested	正在请求线程停止。这仅用于内部。
Suspended	线程已挂起。
SuspendRequested	正在请求线程挂起。
Unstarted	尚未对线程调用 Thread.Start 方法。
WaitSleepJoin	由于调用 Wait、Sleep 或 Join，线程已被阻止。

下表列出导致状态更改的操作。

操作	ThreadState
在公共语言运行库中创建线程。	Unstarted
线程调用 Start	Unstarted
线程开始运行。	Running
线程调用 Sleep	WaitSleepJoin
线程对其他对象调用 Wait。	WaitSleepJoin
线程对其他线程调用 Join。	WaitSleepJoin
另一个线程调用 Interrupt	Running
另一个线程调用 Suspend	SuspendRequested
线程响应 Suspend 请求。	Suspended
另一个线程调用 Resume	Running
另一个线程调用 Abort	AbortRequested
线程响应 Abort 请求。	Stopped
线程被终止。	Stopped

演示代码如下所示：

Copy

static void Main(string[] args) { Console.WriteLine("开始执行..."); Thread t = new Thread(PrintNumbersWithStatus); Thread t2 = new Thread(DoNothing); // 使用ThreadState查看线程状态 此时线程未启动，应为Unstarted Console.WriteLine($"Check 1 :{t.ThreadState}"); t2.Start(); t.Start(); // 线程启动， 状态应为 Running Console.WriteLine($"Check 2 :{t.ThreadState}"); // 由于PrintNumberWithStatus方法开始执行，状态为Running // 但是经接着会执行Thread.Sleep方法 状态会转为 WaitSleepJoin for (int i = 1; i < 30; i++) { Console.WriteLine($"Check 3 : {t.ThreadState}"); } // 延时一段时间，方便查看状态 Thread.Sleep(TimeSpan.FromSeconds(6)); // 终止线程 t.Abort(); Console.WriteLine("t线程被终止"); // 由于该线程是被Abort方法终止 所以状态为 Aborted或AbortRequested Console.WriteLine($"Check 4 : {t.ThreadState}"); // 该线程正常执行结束 所以状态为Stopped Console.WriteLine($"Check 5 : {t2.ThreadState}"); Console.ReadKey(); } static void DoNothing() { Thread.Sleep(TimeSpan.FromSeconds(2)); } static void PrintNumbersWithStatus() { Console.WriteLine("t线程开始执行..."); // 在线程内部，可通过Thread.CurrentThread拿到当前线程Thread对象 Console.WriteLine($"Check 6 : {Thread.CurrentThread.ThreadState}"); for (int i = 1; i < 10; i++) { Thread.Sleep(TimeSpan.FromSeconds(2)); Console.WriteLine($"t线程输出 ：{i}"); } }

运行结果如下图所示，与预期的结果一致。

1.7 线程优先级#

Windows操作系统为抢占式多线程(Preemptive multithreaded)操作系统，是因为线程可在任何时间停止（被枪占）并调度另一个线程。

Windows操作系统中线程有0(最低) ~ 31(最高)的优先级，而优先级越高所能占用的CPU时间就越多，确定某个线程所处的优先级需要考虑进程优先级和相对线程优先级两个优先级。

1. 进程优先级：Windows支持6个进程优先级，分别是Idle、Below Normal、Normal、Above normal、High 和Realtime。默认为Normal。
2. 相对线程优先级：相对线程优先级是相对于进程优先级的，因为进程包含了线程。Windows支持7个相对线程优先级，分别是Idle、Lowest、Below Normal、Normal、Above Normal、Highest 和 Time-Critical.默认为Normal。

下表总结了进程的优先级和线程的相对优先级与优先级(0~31)的映射关系。粗体为相对线程优先级，斜体为进程优先级。

	Idle	Below Normal	Normal	Above Normal	High	Realtime
Time-Critical	15	15	15	15	15	31
Highest	6	8	10	12	15	26
Above Normal	5	7	9	11	14	25
Normal	4	6	8	10	13	24
Below Normal	3	5	7	9	12	23
Lowest	2	4	6	8	11	22
Idle	1	1	1	1	1	16

而在C#程序中，可更改线程的相对优先级，需要设置Thread的Priority属性，可设置为ThreadPriority枚举类型的五个值之一：Lowest、BelowNormal、Normal、AboveNormal 或 Highest。CLR为自己保留了Idle和Time-Critical优先级，程序中不可设置。

演示代码如下所示。

Copy

static void Main(string[] args) { Console.WriteLine($"当前线程优先级: {Thread.CurrentThread.Priority} \r\n"); // 第一次测试，在所有核心上运行 Console.WriteLine("运行在所有空闲的核心上"); RunThreads(); Thread.Sleep(TimeSpan.FromSeconds(2)); // 第二次测试，在单个核心上运行 Console.WriteLine("\r\n运行在单个核心上"); // 设置在单个核心上运行 System.Diagnostics.Process.GetCurrentProcess().ProcessorAffinity = new IntPtr(1); RunThreads(); Console.ReadLine(); } static void RunThreads() { var sample = new ThreadSample(); var threadOne = new Thread(sample.CountNumbers); threadOne.Name = "线程一"; var threadTwo = new Thread(sample.CountNumbers); threadTwo.Name = "线程二"; // 设置优先级和启动线程 threadOne.Priority = ThreadPriority.Highest; threadTwo.Priority = ThreadPriority.Lowest; threadOne.Start(); threadTwo.Start(); // 延时2秒 查看结果 Thread.Sleep(TimeSpan.FromSeconds(2)); sample.Stop(); } class ThreadSample { private bool _isStopped = false; public void Stop() { _isStopped = true; } public void CountNumbers() { long counter = 0; while (!_isStopped) { counter++; } Console.WriteLine($"{Thread.CurrentThread.Name} 优先级为 {Thread.CurrentThread.Priority,11} 计数为 = {counter,13:N0}"); } }

运行结果如下图所示。Highest占用的CPU时间明显多于Lowest。当程序运行在所有核心上时，线程可以在不同核心同时运行，所以Highest和Lowest差距会小一些。

1.8 前台线程和后台线程#

在CLR中，线程要么是前台线程，要么就是后台线程。当一个进程的所有前台线程停止运行时，CLR将强制终止仍在运行的任何后台线程，不会抛出异常。

在C#中可通过Thread类中的IsBackground属性来指定是否为后台线程。在线程生命周期中，任何时候都可从前台线程变为后台线程。线程池中的线程默认为后台线程。

演示代码如下所示。

Copy

static void Main(string[] args) { var sampleForeground = new ThreadSample(10); var sampleBackground = new ThreadSample(20); var threadPoolBackground = new ThreadSample(20); // 默认创建为前台线程 var threadOne = new Thread(sampleForeground.CountNumbers); threadOne.Name = "前台线程"; var threadTwo = new Thread(sampleBackground.CountNumbers); threadTwo.Name = "后台线程"; // 设置IsBackground属性为 true 表示后台线程 threadTwo.IsBackground = true; // 线程池内的线程默认为 后台线程 ThreadPool.QueueUserWorkItem((obj) => { Thread.CurrentThread.Name = "线程池线程"; threadPoolBackground.CountNumbers(); }); // 启动线程 threadOne.Start(); threadTwo.Start(); } class ThreadSample { private readonly int _iterations; public ThreadSample(int iterations) { _iterations = iterations; } public void CountNumbers() { for (int i = 0; i < _iterations; i++) { Thread.Sleep(TimeSpan.FromSeconds(0.5)); Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}"); } } }

运行结果如下图所示。当前台线程10次循环结束以后，创建的后台线程和线程池线程都会被CLR强制结束。

1.9 向线程传递参数#

向线程中传递参数常用的有三种方法，构造函数传值、Start方法传值和Lambda表达式传值，一般常用Start方法来传值。

演示代码如下所示，通过三种方式来传递参数，告诉线程中的循环最终需要循环几次。

Copy

static void Main(string[] args) { // 第一种方法 通过构造函数传值 var sample = new ThreadSample(10); var threadOne = new Thread(sample.CountNumbers); threadOne.Name = "ThreadOne"; threadOne.Start(); threadOne.Join(); Console.WriteLine("--------------------------"); // 第二种方法 使用Start方法传值 // Count方法 接收一个Object类型参数 var threadTwo = new Thread(Count); threadTwo.Name = "ThreadTwo"; // Start方法中传入的值 会传递到 Count方法 Object参数上 threadTwo.Start(8); threadTwo.Join(); Console.WriteLine("--------------------------"); // 第三种方法 Lambda表达式传值 // 实际上是构建了一个匿名函数 通过函数闭包来传值 var threadThree = new Thread(() => CountNumbers(12)); threadThree.Name = "ThreadThree"; threadThree.Start(); threadThree.Join(); Console.WriteLine("--------------------------"); // Lambda表达式传值 会共享变量值 int i = 10; var threadFour = new Thread(() => PrintNumber(i)); i = 20; var threadFive = new Thread(() => PrintNumber(i)); threadFour.Start(); threadFive.Start(); } static void Count(object iterations) { CountNumbers((int)iterations); } static void CountNumbers(int iterations) { for (int i = 1; i <= iterations; i++) { Thread.Sleep(TimeSpan.FromSeconds(0.5)); Console.WriteLine($"{Thread.CurrentThread.Name} prints {i}"); } } static void PrintNumber(int number)