C# 并发编程：多线程基础 – wiki基地

作者： /

C# 并发编程：多线程基础深度解析

在现代软件开发中，为了充分利用多核处理器性能、提高应用程序响应速度或处理耗时操作，并发编程变得越来越重要。C#作为一门功能强大的编程语言，提供了丰富的工具和机制来实现并发。本文将深入探讨C#并发编程的基础——多线程，帮助你理解线程的概念、如何创建和管理线程、多线程带来的挑战以及基本的同步技术。

第一部分：理解并发与多线程

1. 什么是并发？

并发（Concurrency）是指一个系统中存在多个执行流（任务），这些任务在同一时间段内向前推进，即使它们可能不是在严格意义上的同一时刻执行。这使得程序能够同时处理多个事情，例如一边下载文件一边浏览网页，或者一个服务器同时响应多个客户端请求。

2. 并发与并行：有什么区别？

  • 并发 (Concurrency): 多个任务交替执行，给人一种“同时进行”的感觉。这可以在单核处理器上实现，操作系统通过时间片轮转等机制快速切换任务。
  • 并行 (Parallelism): 多个任务在 同一时刻 执行。这要求系统拥有多个执行单元（如多核处理器），每个核心可以真正同时执行一个任务。

多线程是实现并发和并行的一种常见手段。在一个多核系统中，多线程程序可以实现真正的并行，显著提升性能。即使在单核系统中，多线程也能通过并发提升程序的响应性（如不阻塞UI）和吞吐量（通过隐藏I/O等待时间）。

3. 什么是进程与线程？

理解多线程，必须先理解进程和线程的概念。

  • 进程 (Process): 是操作系统分配资源（如内存、文件句柄、网络端口等）的基本单位。每个进程都有自己独立的内存空间，一个进程中的代码修改内存不会影响到其他进程。进程是程序的一次执行实例。
  • 线程 (Thread): 是CPU调度的基本单位。一个进程可以包含一个或多个线程。同一个进程中的所有线程共享该进程的资源（内存空间、文件句柄等）。线程是进程中的一个执行路径。

可以把进程想象成一个应用程序，而线程则是应用程序内部的多个“工人”。这些工人在同一个“工厂”（进程）里工作，共享工厂的资源，但每个人负责自己的具体任务。

4. 为什么需要多线程？

使用多线程主要有以下几个目的：

  • 提高应用程序响应性 (Responsiveness): 将耗时的操作（如文件读写、网络请求、复杂计算）放在单独的线程中执行，可以防止主线程（通常是UI线程）被阻塞，使得应用程序界面保持流畅和响应。
  • 提升性能 (Performance): 在多核处理器上，通过将计算密集型任务分解到多个线程中并行执行，可以显著缩短总的执行时间。
  • 简化程序设计 (Simplicity for Specific Problems): 对于某些天然具有并发性的问题（如服务器处理多个客户端连接），使用多线程可以使得代码逻辑更清晰，每个线程负责处理一个独立的连接。
  • 利用 I/O 等待时间 (Utilizing I/O Bound Time): 当一个线程执行I/O操作（如从磁盘读取数据）时，CPU会空闲下来等待数据。多线程可以在一个线程等待I/O时，让另一个线程继续执行计算任务，从而提高CPU的利用率。

第二部分：C# 中的多线程基础

C#/.NET Framework 提供了多种实现多线程的方式，从最初的 System.Threading.Thread 类到后来的线程池、TPL (Task Parallel Library) 和 async/await。本文将重点介绍最基础的 System.Threading.Thread 类和线程池。

1. System.Threading.Thread 类

System.Threading.Thread 类是.NET Framework 中用于创建和控制线程的最基本方式。通过实例化 Thread 类并指定要执行的方法，可以创建一个新的线程。

1.1 创建和启动线程

创建线程需要将一个委托（指向要执行的方法）传递给 Thread 构造函数。这个委托可以是 ThreadStart（无参数无返回值）或 ParameterizedThreadStart（一个 object 参数无返回值）。

“`csharp
using System;
using System.Threading;

public class ThreadExample
{
// 方法签名匹配 ThreadStart 委托
public static void DoWork()
{
for (int i = 0; i < 5; i++)
{
Console.WriteLine($”Worker thread: {i}”);
Thread.Sleep(100); // 模拟耗时操作
}
}

// 方法签名匹配 ParameterizedThreadStart 委托
public static void DoWorkWithParam(object data)
{
    if (data is int limit)
    {
        for (int i = 0; i < limit; i++)
        {
            Console.WriteLine($"Parameterized Worker thread: {i}");
            Thread.Sleep(50);
        }
    }
}

public static void Main(string[] args)
{
    // 1. 使用 ThreadStart 创建和启动线程
    Thread workerThread = new Thread(DoWork);
    Console.WriteLine("Starting worker thread...");
    workerThread.Start(); // 启动线程

    // 2. 使用 ParameterizedThreadStart 创建和启动线程
    Thread parameterizedWorkerThread = new Thread(DoWorkWithParam);
    Console.WriteLine("Starting parameterized worker thread...");
    parameterizedWorkerThread.Start(10); // 启动线程并传递参数

    // 主线程继续执行
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine($"Main thread: {i}");
        Thread.Sleep(150);
    }

    Console.WriteLine("Main thread finished.");
    // 注意：主线程结束时，如果workerThread是前台线程，程序会等待它完成；
    // 如果是后台线程，程序会直接退出。
}

}
“`

在这个例子中，我们创建了两个新的线程，它们与主线程并发执行。Start() 方法会立即启动新的线程，操作系统会将其加入调度队列。

1.2 线程的状态 (Thread State)

线程在其生命周期中会经历多种状态。了解这些状态有助于理解线程的行为和调试多线程程序：

  • Unstarted: 线程已被创建，但 Start() 方法尚未调用。
  • Running: 线程正在执行。
  • WaitSleepJoin: 线程被阻塞，原因可能是：
    • 调用了 Thread.Sleep() 方法，主动休眠。
    • 调用了另一个线程的 Join() 方法，等待该线程完成。
    • 等待进入或重新进入一个监视器锁（通过 lock 关键字或 Monitor 类）。
    • 等待其他同步对象（如 Mutex, Semaphore）。
  • Suspended: 线程已被暂停（已弃用，不推荐使用 Suspend() 和 Resume()）。
  • Stopped: 线程已完成执行或被终止。
  • AbortRequested: 线程收到了 Abort() 请求（已弃用，不推荐使用）。
  • Aborted: 线程因 Abort() 调用而终止（已弃用，不推荐使用）。

可以使用 thread.ThreadState 属性获取当前线程的状态，但这主要用于调试和日志记录，不应作为同步机制的依据，因为线程状态可能随时改变。

1.3 等待线程完成 (Joining Threads)

有时，主线程需要等待一个或多个子线程完成其工作后才能继续执行。可以使用 Join() 方法来实现这一目的。

“`csharp
using System;
using System.Threading;

public class JoinExample
{
public static void DoWork()
{
Console.WriteLine(“Worker thread started.”);
Thread.Sleep(2000); // 模拟耗时操作
Console.WriteLine(“Worker thread finished.”);
}

public static void Main(string[] args)
{
    Thread workerThread = new Thread(DoWork);
    workerThread.Start();

    Console.WriteLine("Main thread waiting for worker thread to finish...");
    workerThread.Join(); // 主线程等待 workerThread 完成

    Console.WriteLine("Worker thread has finished. Main thread continues.");
}

}
“`

Join() 方法会阻塞调用它的线程（在这里是主线程），直到目标线程（workerThread）执行完毕。Join() 也有带超时的重载版本，可以在等待指定时间后放弃等待。

1.4 前台线程与后台线程 (Foreground vs. Background Threads)

线程可以是前台线程或后台线程。它们的区别在于它们是否会阻止应用程序终止：

  • 前台线程 (Foreground Threads): 只要至少有一个前台线程在运行，应用程序进程就不会终止。主线程默认是前台线程。
  • 后台线程 (Background Threads): 应用程序进程会在所有前台线程都结束后立即终止，不管是否有后台线程仍在运行。后台线程通常用于执行不需要阻止应用程序退出的任务，例如日志记录、监控等。

可以通过设置 thread.IsBackground = true; 将一个线程设置为后台线程。

“`csharp
using System;
using System.Threading;

public class BackgroundThreadExample
{
public static void BackgroundTask()
{
Console.WriteLine(“Background thread started.”);
Thread.Sleep(5000); // 模拟长时间运行
Console.WriteLine(“Background thread finished.”); // 这行可能不会被打印出来
}

public static void Main(string[] args)
{
    Thread bgThread = new Thread(BackgroundTask);
    bgThread.IsBackground = true; // 设置为后台线程
    bgThread.Start();

    Console.WriteLine("Main thread finished quickly.");
    // 主线程在这里结束，因为它没有任何前台线程需要等待。
    // bgThread 是后台线程，所以进程会立即退出，bgThread 可能还没来得及完成。
}

}
“`

在这个例子中，主线程完成后，即使后台线程还在睡眠，整个程序也会立即退出。

1.5 传递参数给线程

前面已经演示过使用 ParameterizedThreadStart 传递一个 object 参数。如果需要传递多个参数或类型安全地传递参数，通常使用匿名方法或 Lambda 表达式，或者在启动线程前将数据作为类成员。

“`csharp
using System;
using System.Threading;

public class PassingDataExample
{
// 使用 Lambda 表达式传递多个参数
public static void Main(string[] args)
{
string message = “Hello”;
int count = 3;

    // 使用 Lambda 表达式创建线程
    // Lambda 表达式可以捕获其所在范围内的局部变量
    Thread workerThread = new Thread(() =>
    {
        Console.WriteLine($"Worker thread received message: {message}");
        for (int i = 0; i < count; i++)
        {
            Console.WriteLine($"Worker count: {i}");
            Thread.Sleep(100);
        }
        Console.WriteLine("Worker thread finished.");
    });

    workerThread.Start();

    Console.WriteLine("Main thread finished.");
    workerThread.Join(); // 等待worker thread完成
}

}
“`

使用 Lambda 表达式或匿名方法是现代 C# 中创建线程并传递参数的常用方式，它比 ParameterizedThreadStart 更灵活和类型安全。

2. 线程池 (Thread Pool)

手动创建和销毁 Thread 对象会有一定的开销。对于大量短小的任务，频繁创建和销毁线程会影响性能。线程池（Thread Pool）机制应运而生，它维护了一个线程的集合，这些线程可以被重用来执行任务。

使用线程池的好处：

  • 减少线程创建和销毁的开销： 线程池中的线程可以重复使用。
  • 限制并发线程数量： 线程池可以控制同时运行的最大线程数，避免创建过多线程导致系统资源耗尽。
  • 简化线程管理： 开发者只需将任务提交给线程池，无需关心线程的生命周期管理。

.NET 中的线程池由 System.Threading.ThreadPool 类提供。它是应用程序域范围内的，所有应用程序代码都可以使用同一个线程池。

2.1 将任务排队到线程池

最基本的使用方式是使用 ThreadPool.QueueUserWorkItem 方法，它接收一个 WaitCallback 委托（一个 object 参数无返回值）和一个可选的状态对象。

“`csharp
using System;
using System.Threading;

public class ThreadPoolExample
{
public static void TaskInThreadPool(object state)
{
// state 参数就是 QueueUserWorkItem 传递的第二个参数
string message = state as string;
Console.WriteLine($”Task in Thread Pool started with state: {message}”);
Thread.Sleep(1000); // 模拟工作
Console.WriteLine(“Task in Thread Pool finished.”);
}

public static void Main(string[] args)
{
    Console.WriteLine("Queuing task to Thread Pool...");

    // 将任务排队到线程池
    ThreadPool.QueueUserWorkItem(TaskInThreadPool, "Hello from Main");

    Console.WriteLine("Task queued. Main thread continues...");

    // 主线程执行其他工作
    Thread.Sleep(2000);

    Console.WriteLine("Main thread finished.");

    // 注意：线程池中的线程默认是后台线程，主线程结束不会等待它们。
    // 为了看到输出，我们这里稍微延长主线程的生命周期。
}

}
“`

ThreadPool.QueueUserWorkItem 比较基础，只能传递一个 object 参数且没有直接获取返回值的机制（需要通过其他方式如回调或共享变量）。

现代 C# 开发中，更倾向于使用 TPL 中的 Task.Run() 或 TaskFactory.StartNew()，它们底层通常也是使用线程池，但提供了更强大的功能，如返回值、异常处理、取消等。尽管如此，理解 ThreadPool.QueueUserWorkItem 有助于理解线程池的基本工作原理。

2.2 线程池的限制

线程池的大小是有限制的，默认情况下，.NET 会根据CPU核心数和系统负载动态调整线程池的大小。可以通过 ThreadPool.SetMinThreads 和 ThreadPool.SetMaxThreads 方法设置线程池的最小和最大线程数，但这通常不推荐手动调整，除非你有充分的理由和深入的理解。

线程池线程是后台线程，这意味着一旦所有前台线程结束，线程池中的任务可能不会完成。

第三部分：多线程带来的挑战

多线程虽然强大，但也引入了新的复杂性。由于多个线程共享进程资源（尤其是内存），如果不小心处理，会导致一些难以调试的问题。

1. 竞争条件 (Race Conditions)

当两个或多个线程尝试同时访问和修改共享数据时，如果最终结果取决于线程执行的精确时序，就会发生竞争条件。这是一个经典的多线程问题。

示例：共享计数器

“`csharp
using System;
using System.Threading;

public class RaceConditionExample
{
private static int counter = 0; // 共享资源

public static void IncrementCounter()
{
    for (int i = 0; i < 100000; i++)
    {
        // 这里的 counter++ 操作实际上不是原子性的，它包含读取、修改、写回三个步骤
        // 这三个步骤可能被其他线程的操作打断
        counter++;
    }
}

public static void Main(string[] args)
{
    Thread t1 = new Thread(IncrementCounter);
    Thread t2 = new Thread(IncrementCounter);

    t1.Start();
    t2.Start();

    t1.Join(); // 等待 t1 完成
    t2.Join(); // 等待 t2 完成

    Console.WriteLine($"Final counter value: {counter}"); // 期望值是 200000，但很可能小于
}

}
“`

在这个例子中，counter++ 操作并非原子操作。当两个线程同时执行 counter++ 时，可能发生以下情况：
1. 线程 A 读取 counter 的值（例如 0）。
2. 线程 B 读取 counter 的值（也是 0）。
3. 线程 A 将读取的值加 1 (得到 1)。
4. 线程 B 将读取的值加 1 (也得到 1)。
5. 线程 A 将结果 1 写回 counter。
6. 线程 B 将结果 1 写回 counter。

结果 counter 的值变成了 1，而不是期望的 2。这种非预期的行为就是竞争条件导致的。

2. 死锁 (Deadlock)

死锁是指两个或多个线程无限期地相互等待对方释放资源而无法继续执行的状态。

发生死锁通常需要满足以下四个条件（Coffman Conditions）：
1. 互斥 (Mutual Exclusion): 资源不能被共享，一次只能由一个线程使用。
2. 持有并等待 (Hold and Wait): 线程已经持有一个资源，并且还在等待获取另一个被其他线程持有的资源。
3. 不可剥夺 (No Preemption): 资源不能被强制从持有它的线程那里夺走，只能由持有资源的线程自愿释放。
4. 循环等待 (Circular Wait): 存在一个线程链，链中的每个线程都在等待下一个线程释放资源。

示例：简单的死锁场景

“`csharp
using System;
using System.Threading;

public class DeadlockExample
{
private static readonly object lock1 = new object();
private static readonly object lock2 = new object();

public static void Thread1Method()
{
    lock (lock1) // 线程1获取 lock1
    {
        Console.WriteLine("Thread 1 acquired lock 1");
        Thread.Sleep(50); // 模拟工作，同时给线程2机会获取 lock2

        lock (lock2) // 线程1尝试获取 lock2
        {
            Console.WriteLine("Thread 1 acquired lock 2");
            // Do work...
        }
    }
}

public static void Thread2Method()
{
    lock (lock2) // 线程2获取 lock2
    {
        Console.WriteLine("Thread 2 acquired lock 2");
        Thread.Sleep(50); // 模拟工作，同时给线程1机会获取 lock1

        lock (lock1) // 线程2尝试获取 lock1
        {
            Console.WriteLine("Thread 2 acquired lock 1");
            // Do work...
        }
    }
}

public static void Main(string[] args)
{
    Thread t1 = new Thread(Thread1Method);
    Thread t2 = new Thread(Thread2Method);

    t1.Start();
    t2.Start();

    // 程序很可能在这里挂起，因为 t1 和 t2 陷入死锁
    Console.WriteLine("Main thread finished. (Hopefully not stuck)");
}

}
“`

在这个例子中，如果线程 1 获取了 lock1 并尝试获取 lock2，同时线程 2 获取了 lock2 并尝试获取 lock1，那么两个线程都会无限期地等待对方释放锁，从而发生死锁。

3. 活锁 (Livelock) 和饥饿 (Starvation)

  • 活锁 (Livelock): 线程没有被阻塞，但它们不断改变状态并相互响应，导致无法向前推进，就像两个人在狭窄走廊相遇，不断地互相让路，结果谁也过不去。
  • 饥饿 (Starvation): 某个线程（或一组线程）长时间无法获得所需的资源（如CPU时间或锁），导致其任务无法完成。这可能是由于其他线程总是优先获得资源，或者资源分配策略不公平造成的。

第四部分：多线程同步基础

为了解决竞争条件等问题，我们需要使用同步机制来协调多个线程对共享资源的访问。

1. 临界区 (Critical Section)

临界区是一段代码，在这段代码中访问共享资源。为了保证数据的一致性，任何时候只允许一个线程进入临界区。

2. lock 关键字和 Monitor 类

C#中最常用和最简单的同步机制是 lock 关键字。lock 关键字用于标记一个语句块为临界区，确保在同一时刻只有一个线程可以执行该语句块。

lock 关键字实际上是 System.Threading.Monitor 类的一个语法糖。Monitor 类提供了更灵活的同步功能。

使用 lock 解决竞争条件示例：

“`csharp
using System;
using System.Threading;

public class LockedCounterExample
{
private static int counter = 0; // 共享资源
private static readonly object counterLock = new object(); // 用于锁定的对象

public static void IncrementCounter()
{
    for (int i = 0; i < 100000; i++)
    {
        // 使用 lock 关键字保护临界区
        lock (counterLock)
        {
            // 这段代码块（临界区）在同一时刻只能被一个线程执行
            counter++;
        }
    }
}

public static void Main(string[] args)
{
    Thread t1 = new Thread(IncrementCounter);
    Thread t2 = new Thread(IncrementCounter);

    t1.Start();
    t2.Start();

    t1.Join();
    t2.Join();

    Console.WriteLine($"Final counter value: {counter}"); // 现在结果应该是 200000
}

}
“`

在这个例子中，lock(counterLock) 会尝试获取 counterLock 对象的独占锁。如果锁已被其他线程持有，当前线程会阻塞，直到锁被释放。一旦当前线程获得锁，它就可以执行 lock 块内的代码。当 lock 块执行完毕（无论正常退出还是发生异常），锁会自动释放。

关于用于锁定的对象：

  • 用于 lock 的对象必须是一个引用类型的实例（类对象）。
  • 不要锁定公共可见的对象（如 this, typeof(MyClass), 字符串常量），因为其他不相关的代码也可能锁定同一个对象，导致意外的死锁或性能问题。通常创建一个私有的 readonly object 字段专门用于锁定。
  • 不要锁定值类型变量，因为每次访问值类型时都会创建一个新的副本，锁定副本没有意义。

Monitor 类：

Monitor 类提供了更底层的同步控制。lock 关键字等价于 Monitor.Enter 和 Monitor.Exit 的组合，并且包含 try...finally 块以确保锁的释放。

csharp
// lock (obj) { ... }
// 大致等价于：
object obj = counterLock; // 假设 counterLock 是用于锁定的对象
bool lockTaken = false;
try
{
Monitor.Enter(obj, ref lockTaken);
// lock 块内的代码
counter++;
}
finally
{
if (lockTaken)
{
Monitor.Exit(obj);
}
}

Monitor 还提供了 Wait(), Pulse(), PulseAll() 方法，用于实现更复杂的线程协作模式（例如生产者/消费者模式），允许一个线程在持有锁的情况下暂时释放锁并等待某个条件满足，然后在条件满足时被其他线程唤醒。这些方法超出了基础范畴，暂不展开。

3. 其他同步原语（简述）

.NET 提供了多种更高级的同步原语，用于处理更复杂的场景：

  • Mutex (互斥锁): 类似于 Monitor，但 Mutex 可以跨进程使用。通常用于同步应用程序不同实例的访问。
  • Semaphore (信号量): 控制同时访问某个资源的线程数量。它维护一个计数器，线程获取信号量会使计数器减一，释放会使计数器加一。当计数器为零时，线程无法获取信号量而被阻塞。
  • EventWaitHandle (ManualResetEvent, AutoResetEvent): 用于线程之间的信号通知。一个线程可以发出信号，另一个线程等待信号。AutoResetEvent 在发出信号后会自动重置，而 ManualResetEvent 需要手动重置。
  • ReaderWriterLock (Slim): 允许多个线程同时读取共享资源，但在写操作时只允许一个线程进行。适用于读多写少的场景，可以提高并发性。

这些同步原语提供了不同的粒度和功能，选择合适的原语取决于具体的同步需求。对于大多数简单的共享数据保护，lock 关键字是首选。

4. 原子操作 (Atomic Operations)

对于一些简单的数值类型操作（如增、减、交换），可以使用 System.Threading.Interlocked 类提供的方法。这些方法执行原子操作，即操作是不可中断的，不需要使用锁。

“`csharp
using System;
using System.Threading;

public class AtomicExample
{
private static int counter = 0;

public static void IncrementCounterAtomic()
{
    for (int i = 0; i < 100000; i++)
    {
        // 使用 Interlocked.Increment 进行原子递增
        Interlocked.Increment(ref counter);
    }
}

public static void Main(string[] args)
{
    Thread t1 = new Thread(IncrementCounterAtomic);
    Thread t2 = new Thread(IncrementCounterAtomic);

    t1.Start();
    t2.Start();

    t1.Join();
    t2.Join();

    Console.WriteLine($"Final counter value: {counter}"); // 结果也是 200000
}

}
“`

Interlocked 类提供了 Increment, Decrement, Add, Exchange, CompareExchange 等原子操作，对于简单的数值操作，它比使用 lock 更高效。

5. 线程安全集合 (Concurrent Collections)

在 .NET Framework 4.0 之后，System.Collections.Concurrent 命名空间引入了一系列线程安全的集合类，如 ConcurrentBag<T>, ConcurrentQueue<T>, ConcurrentStack<T>, ConcurrentDictionary<T>.

这些集合类内部已经处理了同步问题，可以在多个线程中安全地使用，而无需手动添加 lock。使用这些集合类通常比手动锁定非线程安全集合更方便和高效。

第五部分：多线程开发的最佳实践与注意事项

  • 尽量减少锁的范围和持有时间： 锁是多线程并发的瓶颈。只在访问共享资源的关键代码块中使用锁，并且尽快释放锁。
  • 避免在锁内执行耗时操作： 避免在锁内执行 I/O 操作、网络请求或其他可能阻塞当前线程的操作，这会长时间占用锁，影响其他线程的执行。
  • 小心处理跨线程访问 UI 元素： Windows Forms, WPF 等 UI 框架中的 UI 元素通常不是线程安全的，只能在创建它们的线程（通常是主UI线程）中访问。需要使用 Control.Invoke/BeginInvoke (WinForms) 或 Dispatcher.Invoke/BeginInvoke (WPF) 将对UI的操作封送到UI线程执行。
  • 处理线程中的异常： 未处理的异常会向上冒泡。在 .NET Framework 4.0 之前，子线程的未处理异常会导致整个进程终止。在 .NET 4.0 及之后，子线程的未处理异常默认不会终止整个进程，但线程会停止。对于线程池线程或 Task，未处理异常有更复杂的处理机制（如 Task.Exception）。通常应该在线程的入口方法内部捕获并处理异常。
  • 避免使用已弃用的方法： Thread.Abort() 和 Thread.Suspend()/Resume() 方法已被弃用，不应使用。它们可能导致不可预测的行为，如在持有锁的情况下终止线程，造成死锁。应使用协作式的取消机制（如 CancellationToken，通常与 TPL 配合使用）。
  • 优先使用更高级的抽象： 对于许多常见的并发场景（如并行循环、异步操作、任务编排），优先考虑使用 TPL (Task Parallel Library) 和 async/await。它们构建在线程池之上，提供了更易用、更高效、更安全的并发编程模型。理解 Thread 是基础，但实际开发中 Task 更常用。
  • 注意变量的可变性： 共享的可变状态是多线程问题的根源。尽量使用不可变数据，或者限制对共享数据的访问和修改。
  • 使用工具辅助调试： 多线程问题往往难以重现和调试。可以利用 Visual Studio 的并发可视化工具、并行堆栈窗口以及各种诊断工具来帮助分析多线程行为。

第六部分：从基础到现代 C# 并发

本文主要聚焦于最基础的 System.Threading.Thread 和 Thread Pool。需要指出的是，随着 .NET 的发展，出现了更高级、更推荐的并发和异步编程模型。

  • 任务并行库 (TPL – Task Parallel Library): 包含在 System.Threading.Tasks 命名空间中，提供了 Task 和 Task<TResult> 类。Task 代表一个异步操作，它可以是计算密集型的（通常在线程池线程上运行）或 I/O 密集型的（不占用线程直到操作完成）。TPL 提供了并行循环 (Parallel.For, Parallel.ForEach) 等高级功能，极大地简化了并行编程。
  • 异步编程 (async/await): 这是 C# 5.0 引入的一对关键字，用于简化异步编程，特别是在处理 I/O 密集型操作时。async 方法可以在等待另一个异步操作完成时释放当前线程，从而避免阻塞线程。await 关键字用于等待一个 Task 完成。async/await 使得编写异步代码像编写同步代码一样直观。

虽然 Task 和 async/await 是现代 C# 中实现并发和异步的主流方式，但它们底层很多时候仍然依赖于线程池，而线程池中的线程归根结底是由操作系统调度的。因此，理解 System.Threading.Thread 和线程池等基础概念，对于深入理解更高级的并发模型是至关重要的。

总结

C# 多线程是构建响应迅速、高性能应用程序的强大工具。通过 System.Threading.Thread 类，我们可以创建和管理独立的执行流。线程池 (ThreadPool) 提供了更高效的任务调度方式。然而，多线程也带来了竞争条件、死锁等复杂的同步问题。理解和掌握 lock 关键字以及其他同步原语是解决这些问题的关键。

虽然现代 C# 开发更倾向于使用 TPL 和 async/await，但对传统多线程基础的扎实掌握，是理解和有效利用这些高级工具的基石。希望本文能为你构建稳固的 C# 并发编程基础提供帮助。在实践中不断探索和学习，你将能够自信地驾驭多线程的复杂性。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部