C# 多线程编程入门教程

1. 简介
   随着硬件性能的提升，尤其是多核CPU的广泛应用，多线程编程已经成为现代软件开发中的核心技能之一。多线程可以让程序在多个核心上并发运行，提高效率和性能。然而，编写多线程程序并不是一件简单的事情，尤其是要处理线程间的同步问题，以避免数据竞争和死锁等问题。

C# 提供了非常强大的多线程支持，它不仅提供了传统的 Thread 类，还通过 Task Parallel Library (TPL) 提供了更高层次的并行编程模型。本教程旨在帮助读者了解多线程编程的基本概念、常用的多线程技术，并掌握如何在 C# 中创建和管理线程。

2. 线程基础
   2.1 什么是线程？
   线程是操作系统能够进行运算调度的最小单位。一个进程可以包含一个或多个线程，它们共享进程的内存空间，但每个线程都有自己的栈空间。

在单线程应用中，所有代码都是顺序执行的。而多线程应用可以并发执行不同的代码段，从而加快程序的响应速度，尤其是在处理耗时操作时（如文件 I/O 或网络请求）。

2.2 线程的创建与启动
在 C# 中，创建线程非常简单。你可以通过 System.Threading.Thread 类来创建和启动一个新的线程。下面是一个简单的例子：
using System;
using System.Threading;

class Program
{
static void Main()
{
Thread thread = new Thread(PrintNumbers);
thread.Start(); // 启动线程

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

static void PrintNumbers()
{
    for (int i = 1; i <= 5; i++)
    {
        Console.WriteLine($"子线程: {i}");
        Thread.Sleep(1000);
    }
}

}
在这个例子中，主线程和子线程会并发执行。Thread.Sleep(1000) 表示让线程暂停1秒钟，以模拟一些耗时的操作。

2.3 线程的状态
线程在其生命周期中可以处于多种状态：

未启动状态：线程被创建，但尚未调用 Start() 方法。
可运行状态：线程已启动，正在等待 CPU 时间片。
运行状态：线程正在执行。
阻塞状态：线程正在等待某个事件完成，比如等待 I/O 操作完成。
终止状态：线程已经完成执行。
你可以通过 Thread.ThreadState 属性来获取线程的当前状态。
Console.WriteLine(thread.ThreadState); // 输出线程状态
3. 线程同步
多线程编程中的一个主要挑战是如何确保多个线程不会在共享资源上发生冲突。C# 提供了几种机制来处理线程同步问题，以防止线程间的资源竞争。

3.1 锁（Lock）
锁是多线程编程中最常见的同步机制。在 C# 中，lock 语句用于确保同一时间只有一个线程可以访问某个代码块或资源。使用 lock 关键字可以简单地实现线程同步。
class Counter
{
private int _count = 0;
private readonly object _lockObj = new object();

public void Increment()
{
    lock (_lockObj)
    {
        _count++;
        Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId}: {_count}");
    }
}

}

class Program
{
static void Main()
{
Counter counter = new Counter();
Thread[] threads = new Thread[5];

    for (int i = 0; i < 5; i++)
    {
        threads[i] = new Thread(counter.Increment);
        threads[i].Start();
    }
}

}
在这个例子中，lock (_lockObj) 确保了多个线程不会同时执行 _count++ 这段代码，从而避免了数据竞争。

3.2 Monitor 类
Monitor 类提供了更强大的线程同步功能，它可以实现和 lock 相同的功能，但还可以更灵活地控制锁的获取和释放。
class Counter
{
private int _count = 0;
private readonly object _lockObj = new object();

public void Increment()
{
    Monitor.Enter(_lockObj);
    try
    {
        _count++;
        Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId}: {_count}");
    }
    finally
    {
        Monitor.Exit(_lockObj);
    }
}

}
Monitor.Enter() 用来获取锁，而 Monitor.Exit() 则释放锁。使用 finally 确保在任何情况下都能释放锁。

3.3 AutoResetEvent 和 ManualResetEvent
除了锁以外，还有一些其他的线程同步机制。AutoResetEvent 和 ManualResetEvent 是两种基于事件的同步机制，通常用于让一个线程等待另一个线程完成某项任务。
AutoResetEvent autoEvent = new AutoResetEvent(false);

void DoWork()
{
Console.WriteLine(“开始工作…”);
Thread.Sleep(3000); // 模拟长时间操作
Console.WriteLine(“工作完成，通知主线程。”);
autoEvent.Set(); // 通知等待线程
}

Thread workerThread = new Thread(DoWork);
workerThread.Start();

// 主线程等待工作线程完成
Console.WriteLine(“等待工作完成…”);
autoEvent.WaitOne(); // 等待信号
Console.WriteLine(“工作已完成！”);
AutoResetEvent 会在工作线程调用 Set() 后释放等待中的主线程，从而实现线程间的协调。

4. Task 并行库（Task Parallel Library）
   C# 的 Task Parallel Library (TPL) 提供了一种更高层次的并行编程模型，使得我们可以更轻松地创建和管理线程。在 TPL 中，Task 是对 Thread 的一种抽象，它简化了多线程编程中的线程管理和错误处理。

4.1 创建和运行 Task
Task 的创建和启动非常简单，你可以通过 Task.Run 或者 Task.Factory.StartNew 来启动任务。
Task task = Task.Run(() =>
{
for (int i = 1; i <= 5; i++)
{
Console.WriteLine($“Task: {i}”);
Thread.Sleep(1000);
}
});

task.Wait(); // 等待任务完成
Task.Run 用来启动一个任务，task.Wait() 用来阻塞主线程，直到任务完成。

4.2 等待多个 Task
TPL 还提供了等待多个任务的方法。Task.WhenAll 可以等待一组任务全部完成。
Task[] tasks = new Task[3];

for (int i = 0; i < tasks.Length; i++)
{
int taskNum = i; // 避免闭包问题
tasks[i] = Task.Run(() =>
{
Console.WriteLine($"Task {taskNum} 开始执行"); Thread.Sleep(1000 * (taskNum + 1)); Console.WriteLine($“Task {taskNum} 完成”);
});
}

Task.WaitAll(tasks); // 等待所有任务完成
Console.WriteLine(“所有任务都已完成”);
4.3 Task 的异常处理
与 Thread 不同，Task 会自动捕获任务中的异常，并在任务完成时重新抛出。你可以使用 try-catch 块来捕获任务的异常。
try
{
Task task = Task.Run(() =>
{
throw new InvalidOperationException(“任务出错了！”);
});
task.Wait();
}
catch (AggregateException ex)
{
foreach (var innerEx in ex.InnerExceptions)
{
Console.WriteLine($“捕获到异常: {innerEx.Message}”);
}
}
在这个例子中，AggregateException 会捕获并保存所有任务中的异常。

5. 线程池
   线程池（Thread Pool）是操作系统管理的一组线程，专门用于执行短时间的后台任务。线程池的好处是避免了频繁创建和销毁线程的开销。在 C# 中，ThreadPool 类提供了简单的接口来使用线程池。
   ThreadPool.QueueUserWorkItem(_ =>
   {
   Console.WriteLine(“在线程池中执行任务”);
   });
   线程池中的线程是可复用的，当一个任务执行完成后，线程会被返回到池中以便处理下一个任务。

6. 异步编程与多线程
   C# 中的异步编程（async/await）虽然看起来像多线程，但实际上并不完全相同。异步方法主要用于 I/O 密集型操作，它们通过在等待操作完成时释放当前线程来提高效率。在异步方法中，操作是在后台执行，但不一定是通过创建新线程实现的。
   async Task DownloadFileAsync(string url)
   {
   using HttpClient client = new HttpClient();
   string content = await client.GetStringAsync(url);
   Console.WriteLine(“文件下载完成”);
   }
   异步方法允许你编写看起来是同步的代码，但实际上它们是非阻塞的。

7. 总结
   C# 提供了多种多线程编程的机制，从底层的 Thread 类，到高层的 Task 并行库，再到更加灵活的异步编程模型。不同的场景需要不同的多线程技术。在实际开发中，选择合适的工具不仅可以提高应用程序的性能，还可以减少复杂的线程同步问题。

通过学习和掌握本文中的技术，你可以开始编写更高效、更健壮的多线程 C# 应用程序。同时要注意，随着线程数量的增加，代码复杂性和调试难度也会增加，因此在进行多线程编程时，始终要考虑线程同步和资源竞争问题，避免不必要的性能开销和潜在的 bug。