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 类的一些常用的属性：

以下是一个 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 类的一些常用的方法：

下面是一个 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 类的一些常用的属性：
常用属性

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

下面是一个示例代码：

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<object> 作为默认类型。
• Task 类的实例代表一个异步操作，例如一个 I/O 操作或者一个计算密集型的操作。
• 可以使用 Task 对象来监视和控制异步操作的执行过程。在异步执行期间，我们可以通过轮询 Task 对象来检查操作的进度，或者在操作完成时通过 Task 对象来获取操作的结果。

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

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

在使用 Task 类创建线程时，可以使用 Start 方法或 Run 方法来启动线程，二者有以下区别：

• 启动方式：Start 方法会在新线程上执行任务，而 Run 方法则是在当前线程上同步执行任务。

• 线程数量：Start 方法会创建新线程并在其中执行任务，而 Run 方法只会在当前线程上执行任务，不会创建新线程。

• 调用次数：Run 方法可以被多次执行，而 Start 方法只能被执行一次，因为线程不能被重复启动。

• 作用：Run 方法存放任务代码，而 Start 方法同时创建线程并执行任务。

需要注意的是，使用 Start 方法启动的线程可能会在当前线程之后才开始执行，因为它需要等待 CPU 时间片的分配。而使用 Run 方法则会立即执行任务，直到任务执行完毕才会继续执行下面的代码。
此外，使用 Task.Run 方法也可以创建新线程并在其中执行任务，与 Task.Start 方法类似。但是 Task.Run 方法会返回一个 Task 对象，该对象可以用于等待任务执行完毕或者监视任务执行状态。

以下是一个使用 Task 类的简单示例代码，该示例创建了一个异步任务来计算数组中所有元素的平均值：

using System;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        // 定义整数数组
        int[] arr = { 1, 2, 3, 4, 5 };

        // 创建一个Task实例，计算整数数组的平均值
        Task<double> task = Task.Run(() => {
            double sum = 0;
            foreach (int num in arr) {
                sum += num;
            }
            return sum / arr.Length;
        });

        // 输出提示信息
        Console.WriteLine($"Calculating average of array...");

        // 输出Task实例返回的结果（平均值）
        Console.WriteLine($"Average: {task.Result}");
    }
}

在上面的代码中，首先定义了一个整数数组 arr，然后创建了一个 Task 对象，该对象使用 Task.Run() 方法执行一个无参数 Lambda 表达式。Lambda 表达式计算 arr 中所有元素的平均值，然后将结果作为 Task<double> 对象的返回值。

在执行任务期间，Main() 方法可以继续执行其他操作。当需要获取任务的结果时，可以使用 Task.Result 属性，该属性将等待任务完成并返回其结果。

上述代码运行后将输出以下内容：

Calculating average of array…
Average: 3

需要注意的是，如果任务执行过程中发生了异常，则可以通过 Task.Exception 属性获取异常信息。可以通过 Task.IsFaulted 属性来检查任务是否失败。

6、Timer 类

Timer 类允许我们在一段时间间隔内重复执行某些代码，可以使用 Timer 类的构造函数创建计时器。

• 在初始化 Timer 实例时，可以指定一个回调函数来执行代码，以及第一次回调的等待时间和回调间隔时间。然后，Timer 类将在指定的时间间隔内重复执行回调函数。
• 除此之外，Timer 类还有一些可用于更改回调时间或释放资源的方法。

下表列出了 Timer 类的创建语法，以及一些常用的方法：

下面是一个使用 Timer 类的示例代码：

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 创建 TimerCallback 委托对象，指向 PrintTime 方法
        TimerCallback callback = new TimerCallback(PrintTime);

        // 创建 Timer 对象并启动定时器，第一个参数是回调函数，第二个参数传递给回调函数的状态信息，第三个参数是时间间隔，第四个参数是定时器第一次执行的延迟时间
        Timer timer = new Timer(callback, null, TimeSpan.Zero, TimeSpan.FromSeconds(1));

        // 等待用户按下任意键终止定时器
        Console.WriteLine("Press any key to stop the timer");
        Console.ReadKey();

        // 销毁定时器
        timer.Dispose();
        Console.WriteLine("Timer stopped");
    }

    // 定义回调函数 PrintTime
    static void PrintTime(object state)
    {
        Console.WriteLine(DateTime.Now.ToString("hh:mm:ss"));
    }
}

该程序使用 Timer 类每秒打印当前时间。在 Main 方法中，首先创建一个 TimerCallback 委托，该委托指向一个名为 PrintTime 的方法。

然后，创建一个 Timer 实例，并传入 callback 和两个 TimeSpan 参数。第一个参数表示多长时间后开始计时，TimeSpan.Zero 表示立即开始计时。第二个参数表示每隔多长时间执行一次回调函数，TimeSpan.FromSeconds(1) 表示每秒执行一次回调函数。

在程序运行时，通过 Console.ReadKey() 暂停程序，等待用户按下任意键。一旦用户按下任意键，程序将释放 timer 并停止计时。

7、线程同步的相关类

在使用线程时，需要注意线程同步和线程安全问题，避免出现线程间数据竞争和死锁等问题。可以使用 Monitor、Mutex、Semaphore 等类创建同步对象来确保线程安全。

7.1 Monitor 类

Monitor 是 C# 中最基本的同步对象，是一个内置的互斥锁定对象，由 System.Threading.Monitor 类实现。Monitor 对象用于限制在同一时间内只有一个线程可以访问共享资源。

• Monitor 的主要作用是提供一个独占锁来确保线程安全。使得在同一时刻只有一个线程可以进入代码块，进而保证了代码块的互斥性。当一个线程进入被 Monitor 锁定的代码块时，其他线程将被阻塞，直到该线程退出代码块。

下列是常用的一些方法：文章来源地址https://www.toymoban.com/news/detail-658579.html

7.2 Mutex 类

Mutex 是一种系统级别的内核对象，由 System.Threading.Mutex 类实现。Mutex 对象是一种可命名的同步对象，可以跨进程共享。它可以保护多个线程同时访问共享资源，即多线程编程中的互斥锁。

• Mutex 与 Monitor 的最大区别在于，Mutex 可以跨进程共享，而 Monitor 只能在同一个进程内的线程间共享。Mutex 还可以防止饥饿状态的发生，即等待较长时间但一直未被允许进入临界区的线程不会无限期地等待下去。

下列是常用的一些方法：

7.3 Semaphore 类

Semaphore 也是一种同步对象，由 System.Threading.Semaphore 类实现。Semaphore 对象也是用于保护多个线程同时访问一组资源，控制对某个共享资源的访问数量。Semaphore 的使用场景包括线程池和限制并发请求等。

• Semaphore 类中有一个计数器，初始值表示同时可访问该资源的线程数量。每当有一个线程访问该资源时，计数器的值就会减一。当计数器的值为 0 时，后续访问该资源的线程将会被阻塞，直到有一个线程释放该资源，计数器的值才会加一。

下列是常用的一些方法：

到了这里，关于unity的C#学习——多线程编程（线程的生命周期、创建与管理）与线程相关类的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！