C#多线程基础：线程创建、状态管理与同步机制

进程与线程的核心概念

在操作系统中，进程是资源分配的最小单元，而线程是CPU调度的最小单元。一个应用程序（进程）可以包含多个线程，这些线程共享进程的内存空间，但各自拥有独立的执行流。

随着多核CPU的普及，操作系统通过虚拟技术将物理计算能力分割，允许多个程序并发运行。线程正是这一机制的体现，它允许程序在单核或多核环境中并行处理任务。然而，过度使用线程会消耗大量操作系统资源，因此需根据场景权衡使用。

在C#开发中，当遇到以下场景时，通常需要考虑引入多线程：

• 耗时较长的IO操作（如文件读写、网络传输）。
• 重型计算或数据处理任务。
• 需要实时响应的界面交互（避免主线程阻塞）。
• 数据库访问或复杂业务逻辑处理。

线程的生命周期管理

C#中使用 System.Threading.Thread 类来管理线程。以下是线程从创建到终止的基本操作及注意事项。

第1步：创建并启动线程

通过实例化 Thread 对象并传入入口方法，然后调用 Start() 即可启动子线程。由于主线程与子线程并行执行，它们的输出通常会交错出现，体现了多线程的非确定性调度特征。

static void Main(string[] args)
{
    // 创建线程，指定入口方法
    Thread oneThread = new Thread(PrintNumber);
    // 启动子线程
    oneThread.Start();

    // 主线程同时执行相同方法
    PrintNumber();
    
    Console.ReadKey();
}

static void PrintNumber()
{
    Console.WriteLine("开始......");
    for (int i = 0; i < 10; i++)
    {
        Console.WriteLine(i);
    }
}

如上所示，当主线程和子线程同时执行循环输出时，控制台会出现杂乱交叉的输出结果，这直观地展示了线程调度的并行性。

第2步：暂停线程（Sleep）

若需让当前线程暂时停止执行并释放CPU时间片，可使用 Thread.Sleep。该方法使线程进入休眠状态，直到指定时间过去或收到中断信号。

// 暂停当前线程2秒
Thread.Sleep(TimeSpan.FromSeconds(2));

第3步：等待线程结束（Join）

当主线程需要等待某个子线程完成特定任务后才能继续执行时，应使用 Join()。此方法会将调用者（主线程）阻塞，直到目标线程执行完毕。

static void Main(string[] args)
{
    Thread oneThread = new Thread(PrintNumber);
    oneThread.Start();
    
    // 阻塞主线程，直到oneThread执行完毕
    oneThread.Join();

    // 此处代码仅在子线程结束后执行
    Console.WriteLine("子线程已完成，主线程继续...");
}

第4步：终止线程（Abort）及其风险

虽然可以使用 Thread.Abort() 强制终止线程，但在现代C#开发中强烈建议避免使用。原因如下：

1. 数据丢失风险：Abort 会向目标线程注入 ThreadAbortException。如果线程正在处理关键数据（如写入文件、提交事务），异常可能导致未保存的操作被中断，且异常可能被线程内的 catch 块捕获并吞没，导致状态不一致。
2. 不可控性：Abort 不能保证线程立即完全退出，特别是在存在finally块或长时间运行的操作时。

最佳实践替代方案：推荐使用标志位（CancellationToken）控制线程优雅退出。例如定义一个布尔变量 isRunning，在线程循环中检查该变量，若为false则自行退出循环。

线程状态与优先级

可以通过 Thread.ThreadState 属性获取线程当前状态（如 Running, Suspended, Stopped 等）。此外，虽然可以设置 Thread.Priority（如 Highest, Lowest），但由于现代操作系统和硬件的多核特性，线程优先级的调整对实际性能的影响已非常有限，仅建议在特定批处理场景下谨慎使用。

前台线程与后台线程

C#中的线程默认属于前台线程。只要进程中还有任意一个前台线程在运行，应用程序就不会结束。相反，后台线程（通过将 IsBackground 设置为 true）不会阻止进程退出。

• 前台线程：程序会等待其执行完毕才关闭进程。常用于关键业务逻辑。
• 后台线程：当所有前台线程结束时，即使后台线程仍在运行，进程也会直接终止。常用于轮询服务、日志清理等非关键任务。

解决竞争条件：Lock同步机制

在多线程环境中，当多个线程同时访问共享资源（如全局变量）时，可能会发生竞争条件（Race Condition），导致数据错误或程序崩溃。例如，两个线程同时对一个计数器进行增减操作，最终结果可能不正确。

竞态条件示例

以下代码中，若无保护机制，count 的值将因线程切换而变得不可预测：

class PeopleCount 
{
    int count = 0;
    public void AddCount() 
    {
        // 非原子操作，易受干扰
        ++count;            
    }
    public void DeleteCount() 
    {
        --count;
    }    
}

使用 Lock 实现互斥访问

lock 关键字是C#中最常用的同步原语之一。它确保在同一时刻，只有一个线程可以执行被 lock 保护的代码块，其他试图进入该块的线程将被阻塞，直到锁被释放。

关键要点：

1. 锁定对象的选择：建议使用 private readonly object _syncRoot = new object(); 作为锁对象。避免锁定 this 或类型对象（typeof(...)），以免引发意外的外部锁冲突。
2. 缩小锁范围：仅在访问共享数据的临界区加锁，避免在整个方法上加锁，以减少线程阻塞时间，提升性能。
3. 原子性保障：lock 确保了其内部代码块的原子性执行。

class PeopleCount 
{
    // 专用锁对象，防止外部干扰
    private readonly object _syncRoot = new object();
    int count = 0;
    
    public void AddCount() 
    {
        lock(_syncRoot)
        {
            ++count;            
        }            
    }
    
    public void DeleteCount() 
    {
        lock(_syncRoot)
        {
            --count;
        }
    }    
}

通过合理使用 lock，可以有效避免数据竞争，确保多线程环境下的数据一致性与程序稳定性。当然，频繁加锁会导致性能下降，因此在设计时应尽量简化临界区，必要时可考虑使用 Concurrent 集合或其他无锁数据结构。

总结

C#多线程开发涉及线程创建、生命周期管理、同步控制等多个方面。掌握 Thread 类的基本用法是基础，但更重要的是理解并发带来的潜在风险（如竞争条件）以及如何通过 lock 等机制安全地解决这些问题。在实际项目中，建议优先考虑更高层级的并发抽象（如 Task、Parallel 库），它们能简化代码并更好地利用多核资源。