unity的C#学习——多线程编程（线程的生命周期、创建与管理）与线程相关类

---

多线程编程是 C# 一个比较难且涵盖面比较广的知识点，本文整理仓促而且属于笔记向博客，有些地方必然还存在不严谨和错误，本人会在日后的使用过程中不断完善。如果发现问题或有改进意见可以在评论区提出，我会及时修改。

---

C# 多线程

线程是程序的执行流程，也被称为轻量级进程。一个进程中可以包含多个线程，每个线程有自己独立的运行堆栈和程序计数器，可以独立地执行不同的任务。

我们编写的程序到目前为止只有一个线程，作为应用程序的运行实例，也就是说它是一个单一的进程在运行。然而，这种方式只能同时执行一个任务，限制了应用程序的并发性能。

为了提高应用程序的效率，我们可以使用线程。通过将程序分为多个线程，可以同时处理多个任务，从而减少等待时间和提高程序的响应速度。线程还可以实现并发编程，充分利用多核处理器的性能，提高应用程序的运行效率。

线程的应用非常广泛，包括但不限于操作系统、Web服务器、数据库、游戏等。

---

1、线程的生命周期

线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。下面列出了线程生命周期中的各种状态：

1. 创建：使用 System.Threading 命名空间中的 Thread 类创建线程实例。
2. 就绪：线程实例被创建后，它进入就绪状态。在此状态下，操作系统为线程分配必要的资源，但线程实际上还没有开始执行。
3. 运行：一旦调用线程的 Start() 方法，线程就会开始执行，并处于运行状态。在此状态下，线程开始执行它的方法体中的代码。
4. 阻塞：线程可能会因为等待某些资源而被阻塞，例如等待用户输入、等待其他线程完成任务等。在此状态下，线程暂时停止执行，并将 CPU 时间片让给其他线程。
5. 终止：当线程完成它的任务、遇到异常或被强制终止时，线程将终止。

---

2、线程的创建与管理

为了创建和控制线程，我们需要使用 System.Threading 命名空间，该命名空间提供了 Thread、ThreadPool、Timer 等等类和接口。通过这些类和接口，我们可以实现多线程编程的核心功能，例如创建和启动线程，管理线程的状态和优先级，控制线程同步和互斥，以及使用定时器来调度线程的执行。

2.1 线程的创建

C# 在 4.0 以后一共有3种创建线程的方式，交给线程执行的方法通过委托传递。

1. Thread 类：
   Thread 类是 C# 中最基本的创建线程的方式。在使用 Thread 类时，需要创建一个 Thread 对象，并将要执行的方法包装在一个 ThreadStart 委托中。然后，可以调用 Thread 对象的 Start 方法来启动线程。

以下是使用 Thread 类创建线程的示例代码：

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread thread = new Thread(new ThreadStart(DoWork));
        thread.Start();

        // 主线程继续执行其他操作
    }

    static void DoWork()
    {
        // 线程要执行的任务
    }
}

2. ThreadPool 类：
   ThreadPool 类是 C# 中一个内置的线程池，可以用于管理和复用多个线程，从而避免频繁地创建和销毁线程，提高程序的性能和效率。在使用 ThreadPool 类时，需要将要执行的方法包装在一个 WaitCallback 委托中，并通过 ThreadPool.QueueUserWorkItem 方法将该委托添加到线程池中。

以下是使用 ThreadPool 类创建线程的示例代码：

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork));

        // 主线程继续执行其他操作
    }

    static void DoWork(object state)
    {
        // 线程要执行的任务
    }
}

3. Task 类：
   Task 类是 C# 4.0 中引入的一种新的线程创建方式，使用 Task 类可以方便地创建异步任务，避免手动管理线程和线程池。在使用 Task 类时，需要创建一个 Task 对象，并将要执行的方法包装在一个 Action 委托中。然后，可以调用 Task 对象的 Start 或 Run 方法来启动线程。

以下是使用 Task 类创建线程的示例代码：

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Task task = new Task(new Action(DoWork));
        task.Start();

        // 主线程继续执行其他操作
    }

    static void DoWork()
    {
        // 线程要执行的任务
    }
}

如果使用 Task.Factory.StartNew() 方法创建任务，不需要调用 Start() 方法，因为任务会在创建后立即启动执行。例如：

Task myTask = Task.Factory.StartNew(DoWork);

创建线程时其实还有简洁写法，可以不需要在被执行方法外部使用 new 委托类型() 来包装。这是因为当被执行方法符合对应委托类型的签名时，编译器会隐式地将方法转换为委托。下面以Thread 类举例说明：

• 使用无参方法，可直接省略：

Thread t = new Thread(MyMethod);
t.Start();

• 使用有参方法，利用无参的 lambda 表达式（在代码块内传参）：

Thread t = new Thread(() => MyMethodWithArgs(arg1, arg2));
t.Start();

• 使用有参方法，利用无参的匿名方法（在代码块内传参）：

Thread t = new Thread(delegate() { MyMethodWithArgs(arg1, arg2); });
t.Start();

2.2 线程的管理

线程的管理涉及到 System.Threading 命名空间下相关类的方法和属性的使用，这里简单举例，在后面介绍相关类的时候进一步介绍。

• Thread.Start() 方法：启动线程。
• Thread.Join() 方法：等待线程执行完毕。
• Thread.Sleep() 方法：暂停当前线程的执行一段时间。
• Thread.Abort() 方法：强制终止线程的执行。
• ThreadState 属性：表示线程的不同状态。

2.3 多线程实例

以下是一个简单的多线程编码实例，它创建了两个线程并在每个线程中执行不同的函数，以便同时执行多个任务：

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 创建第一个线程并启动
        Thread thread1 = new Thread(new ThreadStart(DoTask1));
        /* Thread thread1 = new Thread(DoTask1); */
        thread1.Start();

        // 创建第二个线程并启动
        Thread thread2 = new Thread(new ThreadStart(DoTask2));
        thread2.Start();

        // 等待线程结束
        thread1.Join();
        thread2.Join();

        Console.WriteLine("所有任务已完成");
    }

    static void DoTask1()
    {
        // 执行任务1的代码
        Console.WriteLine("任务1开始执行...");
        Thread.Sleep(3000);
        Console.WriteLine("任务1执行完成");
    }

    static void DoTask2()
    {
        // 执行任务2的代码
        Console.WriteLine("任务2开始执行...");
        Thread.Sleep(5000);
        Console.WriteLine("任务2执行完成");
    }
}

在这个例子中，我们使用 Thread 类来创建和管理线程。我们创建了两个线程，每个线程都调用不同的函数（DoTask1 和 DoTask2）来执行不同的任务。我们使用 Thread.Sleep() 方法来模拟每个任务的耗时，并使用 Join() 方法来等待每个线程的结束。最后，我们在主函数中输出一条消息来表示所有任务已完成。

---

3、Thread 类

Thread 类是 .NET 提供的用于创建和控制线程的基本类。使用 Thread 类可以在应用程序中创建新线程，同时控制线程的状态和执行。

下表列出了 Thread 类的一些常用的属性：

序号	属性	类型	描述
1	CurrentContext	System.Runtime.Remoting.Contexts.Context	获取当前线程正在执行的上下文。上下文是一个逻辑容器，它定义了一个对象的代码执行上下文，包括对象所运行的代码、对象的安全策略和上下文中的属性。
2	CurrentCulture	System.Globalization.CultureInfo	用于确定在将数据类型转换为字符串时要使用的区域性。它主要影响数字和日期时间格式，以及货币和浮点数值的小数点和千位分隔符。 可以通过在程序中显式设置此属性来更改线程的当前区域性。
3	CurrentPrincipal	System.Security.Principal.IPrincipal	在 Windows 操作系统中，用户和组都有关联的安全令牌，这些安全令牌用于授予或拒绝对某些资源的访问权限。CurrentPrincipal 属性可用于检查当前线程的安全令牌，以确定线程是否有访问某个资源的权限。 可以使用该属性来更改当前线程的负责人，以便在运行时更改线程的权限。
4	CurrentThread	System.Threading.Thread	获取当前线程的 Thread 对象。
5	CurrentUICulture	System.Globalization.CultureInfo	用于确定在运行时加载资源文件时使用的区域性。该属性主要用于确定应使用哪个语言和文化特性来显示用户界面（UI）的文本，如按钮、菜单、对话框等。 可以在程序中显式设置此属性来更改线程的当前 UI 区域性。
6	ExecutionContext	System.Threading.ExecutionContext	获取一个 ExecutionContext 对象，该对象包含有关当前线程的各种上下文的信息。这个对象可以被用来在多个线程之间传递上下文信息。
7	IsAlive	bool	判断线程是否处于活动状态。如果线程已经启动并正在运行，则返回 true，否则返回 false。
8	IsBackground	bool	获取或设置一个值，该值指示某个线程是否为后台线程。
9	IsThreadPoolThread	bool	获取一个值，该值指示线程是否属于托管线程池。
10	ManagedThreadId	int	获取当前托管线程的唯一标识符。
11	Name	string	获取或设置线程的名称。
12	Priority	System.Threading.ThreadPriority	获取或设置一个值，该值指示线程的调度优先级。
13	ThreadState	System.Threading.ThreadState	获取线程的当前状态，它是一个枚举类型的值，包括 Unstarted、Running、Stopped、WaitSleepJoin 等状态。

以下是一个 Thread 类使用上述提到的部分属性的示例：

using System;
using System.Globalization;
using System.Threading;

class Program
{
    static void Main()
    {
        // 获取当前线程
        Thread currentThread = Thread.CurrentThread;

        // 设置线程名称
        currentThread.Name = "MyThread";

        // 获取和设置线程优先级
        currentThread.Priority = ThreadPriority.Highest;

        // 获取线程的唯一标识符
        int threadId = currentThread.ManagedThreadId;
        Console.WriteLine($"Thread ID: {threadId}");

        // 获取和设置线程的后台标志
        currentThread.IsBackground = true;

        // 获取线程状态
        ThreadState threadState = currentThread.ThreadState;
        Console.WriteLine($"Thread state: {threadState}");

        // 获取和设置线程的区域性
        CultureInfo cultureInfo = new CultureInfo("en-US");
        currentThread.CurrentCulture = cultureInfo;

        // 获取和设置线程的 UI 区域性
        CultureInfo uiCultureInfo = new CultureInfo("fr-FR");
        currentThread.CurrentUICulture = uiCultureInfo;

        // 获取和设置线程的当前负责人（对基于角色的安全性而言）
        AppDomain.CurrentDomain.SetPrincipalPolicy(System.Security.Principal.PrincipalPolicy.WindowsPrincipal);
        Thread.CurrentPrincipal = new System.Security.Principal.WindowsPrincipal(System.Security.Principal.WindowsIdentity.GetCurrent());

        // 获取和设置线程的 ExecutionContext 对象
        ExecutionContext executionContext = ExecutionContext.Capture();
        currentThread.ExecutionContext = executionContext;

        // 输出线程信息
        Console.WriteLine($"Thread name: {currentThread.Name}");
        Console.WriteLine($"Thread priority: {currentThread.Priority}");
        Console.WriteLine($"Thread background: {currentThread.IsBackground}");
        Console.WriteLine($"Thread culture: {currentThread.CurrentCulture}");
        Console.WriteLine($"Thread UI culture: {currentThread.CurrentUICulture}");
        Console.WriteLine($"Thread principal: {Thread.CurrentPrincipal}");
        Console.WriteLine($"Thread execution context: {currentThread.ExecutionContext}");
    }
}

这个示例代码演示了如何使用 Thread 类的各种实例属性。它创建了一个新的线程，将线程的名称设置为 "MyThread"，优先级设置为最高，将线程设置为后台线程，并获取了线程的唯一标识符和状态。此外，示例还演示了如何获取和设置线程的区域性、UI 区域性、当前负责人和 ExecutionContext 对象。最后，示例输出了所有线程信息。

下表列出了 Thread 类的一些常用的方法：

序号	方法名	描述
1	public void Abort()	在调用此方法的线程上引发 ThreadAbortException 异常，以开始终止此线程的过程。调用此方法通常会销毁线程，并触发 finally 块。
2	public static LocalDataStoreSlot AllocateDataSlot()	在所有的线程上分配未命名的数据槽。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
3	public static LocalDataStoreSlot AllocateNamedDataSlot( string name)	在所有线程上分配已命名的数据槽。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
4	public static void BeginCriticalRegion()	通知主机执行将要进入一个代码区域，在该代码区域内线程中止或未经处理的异常的影响可能会危害应用程序域中的其他任务。
5	public static void BeginThreadAffinity()	通知主机托管代码将要执行依赖于当前物理操作系统线程的标识的指令。
6	public static void EndCriticalRegion()	通知主机执行将要进入一个代码区域，在该代码区域内线程中止或未经处理的异常仅影响当前任务。
7	public static void EndThreadAffinity()	通知主机托管代码已执行完依赖于当前物理操作系统线程的标识的指令。
8	public static void FreeNamedDataSlot(string name)	为进程中的所有线程消除名称与槽之间的关联。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
9	public static Object GetData( LocalDataStoreSlot slot )	在当前线程的当前域中从当前线程上指定的槽中检索值。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
10	public static AppDomain GetDomain()	返回当前线程正在其中运行的当前域。
11	public static AppDomain GetDomainID()	返回唯一的应用程序域标识符。
12	public static LocalDataStoreSlot GetNamedDataSlot( string name )	查找已命名的数据槽。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
13	public void Interrupt()	中断处于 WaitSleepJoin 线程状态的线程。
14	public void Join()	在继续执行标准的 COM 和 SendMessage 消息泵处理期间，阻塞调用线程，直到某个线程终止为止。此方法有不同的重载形式。
15	public static void MemoryBarrier()	同步内存存取：执行当前线程的处理器在对指令重新排序时，不能采用先执行 MemoryBarrier 调用之后的内存存取，再执行 MemoryBarrier 调用之前的内存存取的方式。
16	public static void ResetAbort()	取消为当前线程请求的 Abort。
17	public void Resume()	恢复挂起的线程。（已和 Suspend 一同被废弃）
18	public static void SetData(LocalDataStoreSlot slot, Object data)	在当前正在运行的线程上为此线程的当前域在指定槽中设置数据。为了获得更好的性能，请改用以 ThreadStaticAttribute 属性标记的字段。
19	public void Start()	开始一个线程。
20	public static void Sleep(int millisecondsTimeout)	让线程暂停一段时间，注意时间单位是毫秒。
21	public void Suspend()	挂起线程。（已被废弃，因为容易导致死锁和应用程序崩溃）
22	public static void SpinWait(int iterations)	导致线程等待由 iterations 参数定义的时间量。
23	public static byte VolatileRead(ref byte address) public static double VolatileRead(ref double address) public static int VolatileRead(ref int address) public static Object VolatileRead(ref Object address)	读取字段值。无论处理器的数目或处理器缓存的状态如何，该值都是由计算机的任何处理器写入的最新值。此方法有不同的重载形式，这里只给出了一些形式。
24	public static void VolatileWrite(ref byte address, byte value) public static void VolatileWrite(ref double address, double value) public static void VolatileWrite(ref int address, int value) public static void VolatileWrite(ref Object address, Object value)	立即向字段写入一个值，以使该值对计算机中的所有处理器都可见。此方法有不同的重载形式。这里只给出了一些形式。
25	public static bool Yield()	导致调用线程执行准备好在当前处理器上运行的另一个线程。由操作系统选择要执行的线程。

下面是一个 Thread 类使用上述提到的部分方法和属性的示例代码：

using System;
using System.Threading;

public class Example
{
    public static void Main()
    {
        // 创建一个新的线程，并指定线程函数
        Thread t = new Thread(new ThreadStart(ThreadFunction));
        t.Name = "MyThread";
        t.Priority = ThreadPriority.Highest;

        // 启动线程
        t.Start();

        // 当前线程等待子线程完成
        t.Join();

        // 给子线程发送中断信号
        t.Interrupt();

        // 判断线程是否仍在运行
        if (t.IsAlive)
        {
            Console.WriteLine("Thread is still running.");
        }

        /* 挂起线程
        t.Suspend();
        Console.WriteLine("Thread is suspended."); */

        /* 恢复线程
        t.Resume();
        Console.WriteLine("Thread is resumed."); */

        // 终止线程
        t.Abort();
    }

    public static void ThreadFunction()
    {
        try
        {
            // 休眠 2 秒
            Thread.Sleep(2000);

            // 输出线程名称和优先级
            Console.WriteLine("Thread name: {0}", Thread.CurrentThread.Name);
            Console.WriteLine("Thread priority: {0}", Thread.CurrentThread.Priority);
        }
        catch (ThreadInterruptedException e)
        {
            Console.WriteLine(e);
        }
    }
}

这个示例代码创建了一个新的线程，并指定了一个线程函数 ThreadFunction。

---

4、ThreadPool 类

ThreadPool 类是 C# 中用于管理线程池的类。它可以使程序员更方便地管理多个线程，而无需手动创建和销毁线程。

• 线程池（ThreadPool）是一种可重用的线程集合，它可以执行多个任务，而不必在每个任务完成后启动新线程。

• 线程池在应用程序启动时会创建一定数量的线程，并将它们保存在线程池中，这些线程称为工作线程。当需要执行任务时，应用程序会将任务添加到线程池的队列中，线程池会自动分配空闲的工作线程来执行这些任务。当任务完成后，工作线程会返回到线程池中，等待下一个任务的分配。

• 使用线程池可以避免频繁地创建和销毁线程，从而减少系统开销和资源浪费。线程池还可以控制同时执行的线程数，防止系统过载，提高应用程序的稳定性和可靠性。

下表列出了 ThreadPool 类的一些常用的属性：
常用属性

序号	属性	类型	描述
1	AvailableThreads	int	获取可用于执行工作项的空闲工作线程数
2	CompletedWorkItemCount	int	获取已完成的工作项数量
3	IsThreadPoolThread	bool	获取当前线程是否属于线程池
4	MaxThreads	int	获取或设置线程池可同时拥有的最大工作线程数。
5	MinThreads	int	获取或设置线程池可同时拥有的最小工作线程数。
6	PendingWorkItemCount	int	获取等待执行的工作项数量
7	ThreadCount	int	获取当前正在运行的线程池中的工作线程数

下表列出了 ThreadPool 类的一些常用的方法：

序号	方法名	描述
1	public static bool QueueUserWorkItem(WaitCallback callBack)	将方法排队到线程池的工作队列中，等待执行。
2	public static bool QueueUserWorkItem(WaitCallback callBack, object state)	将带有状态信息的工作项排入线程池的工作队列中，等待执行。
3	public static void GetMaxThreads(out int workerThreads, out int completionPortThreads)	检索可同时处于活动状态的线程数的最大值。
4	public static void GetMinThreads(out int workerThreads, out int completionPortThreads)	检索线程池允许的最小线程数。
5	public static bool SetMaxThreads(int workerThreads, int completionPortThreads)	设置线程池中允许的最大线程数和异步 I/O 线程数。
6	static bool SetMinThreads(int workerThreads, int completionPortThreads)	设置线程池中允许的最小线程数和异步 I/O 线程数。
7	public static bool UnsafeQueueNativeOverlapped(NativeOverlapped* overlapped, IOCompletionCallback iocb, object state)	使用指定的回调函数将 NativeOverlapped 结构排队到线程池以便进行异步 I/O 操作。
8	public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state)	将工作项排入线程池的工作队列中等待执行，但不强制线程池线程在调用方法之前获得安全上下文。

下面是一个示例代码：

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 获取当前线程池的最大线程数和空闲线程数
        int maxThreads, availableThreads;
        ThreadPool.GetMaxThreads(out maxThreads, out _); // 获取最大线程数
        ThreadPool.GetAvailableThreads(out availableThreads, out _); // 获取可用线程数
        Console.WriteLine($"MaxThreads: {maxThreads}, AvailableThreads: {availableThreads}");

        // 提交工作项到线程池
        ThreadPool.QueueUserWorkItem(WorkItemCallback, "Hello, world!"); // 将工作项提交到线程池中
        Console.WriteLine("Work item submitted to thread pool");

        // 等待工作项完成
        EventWaitHandle waitHandle = new ManualResetEvent(false); // 创建一个事件等待句柄
        ThreadPool.QueueUserWorkItem(_ => {
            Console.WriteLine("Working on a task...");
            Thread.Sleep(1000); // 模拟长时间运行的工作项
            Console.WriteLine("Task completed!");
            waitHandle.Set(); // 通知等待句柄任务已完成
        });
        waitHandle.WaitOne(); // 等待等待句柄收到通知
        Console.WriteLine("Task has finished");

        // 等待所有工作项完成
        ManualResetEvent allTasksCompleted = new ManualResetEvent(false); // 创建一个事件等待句柄
        for (int i = 0; i < 10; i++)
        {
            ThreadPool.QueueUserWorkItem(_ => {
                Console.WriteLine($"Working on task {i}...");
                Thread.Sleep(1000); // 模拟长时间运行的工作项
                Console.WriteLine($"Task {i} completed!");
                if (Interlocked.Decrement(ref remainingTasks) == 0) // 如果剩余任务数量为0，则通知所有任务已完成
                {
                    allTasksCompleted.Set();
                }
            });
        }
        allTasksCompleted.WaitOne(); // 等待所有任务完成
        Console.WriteLine("All tasks have completed");

        // 等待线程池中的所有线程退出
        ThreadPool.SetMaxThreads(0, 0); // 设置最大线程数为0
        ThreadPool.SetMinThreads(0, 0); // 设置最小线程数为0
        while (ThreadPool.ThreadCount > 0) // 循环等待线程池中的线程全部退出
        {
            Console.WriteLine($"Waiting for {ThreadPool.ThreadCount} threads to exit...");
            Thread.Sleep(1000);
        }

        Console.WriteLine("All threads have exited");
    }

    private static int remainingTasks = 10; // 剩余任务数量

    private static void WorkItemCallback(object state)
    {
        Console.WriteLine($"Working on {state}...");
        Thread.Sleep(1000); // 模拟长时间运行的工作项
        Console.WriteLine($"{state} completed!");
    }
}

上述代码存在 QueueUserWorkItem 方法与 lambda 表达式的结合使用：

• 我们通过 lambda 表达式声明了一个匿名函数，作为参数传递给 QueueUserWorkItem 方法，其中 _ 是一个占位符，表示 lambda 表达式不需要任何参数。

ThreadPool.QueueUserWorkItem( _ => {
	Console.WriteLine("Working on a task...");
	Thread.Sleep(1000); // 模拟长时间运行的工作项
	Console.WriteLine("Task completed!");
	waitHandle.Set(); // 通知等待句柄任务已完成
});

---

5、Task 类

Task 类是 .NET Framework 中用于支持多线程编程的类之一。它提供了一种异步编程模型，可以在一个线程中执行多个操作，从而提高程序的并发性和效率。Task 类的实例代表一个异步操作，可以使用 Task 对象来监视和控制异步操作的执行过程。

• Task类是泛型类，它可以实例化出具有特定类型返回值的任务。如果不指定类型参数，会使用 Task