C# 多线程开发的详细使用教程

C# 多线程开发是一种强大的技术，用于在多个线程中并行执行代码，以提高应用程序的性能和响应性。本文将详细介绍 C# 中的多线程编程，包括基本概念、常见的多线程方法和技术、线程同步、线程池等，并提供完整示例和最佳实践。

目录

1. 基本概念
2. 创建线程
3. 线程同步
   • 锁机制
   • Monitor 类
   • Mutex (互斥体)
4. 线程池
5. Task 并行库 (TPL)
6. 线程与异步的区别
7. 完整示例
8. 最佳实践
9. 总结

---

1. 基本概念

多线程 是指在程序中创建多个线程并行执行。每个线程都是进程中一个独立的执行流。多线程的主要目的在于提升应用程序的并行性和响应性，尤其在执行长时间的计算任务或 I/O 操作时，多线程可以提高效率。

• 线程（Thread）：是进程中的一个执行路径，一个进程可以包含多个线程。
• UI 线程：在 GUI 应用程序（如 WPF 和 Windows Forms）中，UI 操作必须在主线程（UI 线程）上进行，避免其他线程直接操作 UI。

---

2. 创建线程

在 C# 中，使用 System.Threading.Thread 类可以创建和管理线程。

基本线程创建

通过 Thread 类创建和启动一个新线程。

using System;
using System.Threading;

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

        // 主线程继续执行
        Console.WriteLine("Main thread continues...");
    }

    static void DoWork()
    {
        // 模拟工作
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"Work thread: {i}");
            Thread.Sleep(1000); // 模拟延迟
        }
    }
}

带参数的线程

通过 ParameterizedThreadStart 向线程传递参数。

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        Thread thread = new Thread(new ParameterizedThreadStart(DoWork));
        thread.Start("Hello from thread!"); // 传递参数
    }

    static void DoWork(object message)
    {
        Console.WriteLine(message);
    }
}

使用 Lambda 表达式创建线程

可以使用 Lambda 表达式简化线程的创建过程。

Thread thread = new Thread(() => 
{
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine($"Thread: {i}");
        Thread.Sleep(1000);
    }
});
thread.Start();

线程优先级

线程优先级决定了线程在操作系统中调度的顺序，ThreadPriority 属性可以设置线程的优先级。

Thread thread = new Thread(DoWork);
thread.Priority = ThreadPriority.Highest; // 设置线程优先级
thread.Start();

---

3. 线程同步

在多线程编程中，如果多个线程同时访问共享资源，就可能发生竞态条件（race condition），导致数据不一致。因此，线程同步至关重要。

锁机制

lock 关键字可以确保某个代码块一次只能由一个线程执行，避免多个线程同时访问共享资源。

private static object _lock = new object();

public static void DoWork()
{
    lock (_lock)
    {
        // 线程安全的代码块
        Console.WriteLine("Thread-safe operation");
    }
}

Monitor 类

Monitor 类提供了比 lock 更灵活的线程同步方式，它可以手动控制线程的进入和退出。

private static object _lock = new object();

public static void DoWork()
{
    Monitor.Enter(_lock);  // 手动锁定
    try
    {
        // 线程安全的代码块
        Console.WriteLine("Thread-safe operation");
    }
    finally
    {
        Monitor.Exit(_lock);  // 确保退出锁
    }
}

Mutex (互斥体)

Mutex 用于跨进程的线程同步。与 lock 类似，但它可以在不同的应用程序之间同步。

Mutex mutex = new Mutex();
mutex.WaitOne(); // 请求进入临界区
try
{
    // 线程安全操作
}
finally
{
    mutex.ReleaseMutex(); // 释放互斥体
}

---

4. 线程池

线程池是 C# 中的一种机制，它维护了一组可重用的线程，避免频繁创建和销毁线程的开销。使用 ThreadPool 可以轻松管理后台线程。

ThreadPool.QueueUserWorkItem(DoWork);

public static void DoWork(object state)
{
    Console.WriteLine("Thread from pool");
}

---

5. Task 并行库 (TPL)

Task 是 C# 中用于简化多线程和并行编程的高级抽象。Task 是 .NET 中 Task Parallel Library (TPL) 的核心，它提供了更高层次的并发处理方式。

使用 Task 执行并行操作

Task.Run(() =>
{
    // 模拟并行工作
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine($"Task: {i}");
        Thread.Sleep(1000);
    }
});

Task 的返回值

Task<T> 可以返回一个值，await 可以等待任务完成。

public static async Task<int> CalculateAsync()
{
    return await Task.Run(() =>
    {
        Thread.Sleep(2000);
        return 42;
    });
}

---

6. 线程与异步的区别

多线程和异步编程是并行编程的两种方式。

• 多线程：通过在多个线程中同时执行代码，实现并发处理。
• 异步编程：通过 async 和 await 实现异步执行，异步方法不会阻塞当前线程，而是会在任务完成时继续执行。

两者之间的主要区别在于异步编程通常用于处理 I/O 密集型任务，而多线程更多用于处理 CPU 密集型任务。

---

7. 完整示例

以下是一个使用多线程、线程池、Task 和线程同步的完整示例。

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static object _lock = new object();

    static void Main()
    {
        // 使用 Thread 类
        Thread thread = new Thread(DoWork);
        thread.Start();

        // 使用 ThreadPool
        ThreadPool.QueueUserWorkItem(DoThreadPoolWork);

        // 使用 Task 并行库
        Task.Run(() => DoTaskWork());

        // 使用 lock 进行线程同步
        lock (_lock)
        {
            Console.WriteLine("Main thread in critical section");
        }

        // 等待用户输入结束
        Console.ReadLine();
    }

    static void DoWork()
    {
        lock (_lock)
        {
            Console.WriteLine("Thread in critical section");
            Thread.Sleep(1000);
        }
    }

    static void DoThreadPoolWork(object state)
    {
        Console.WriteLine("Thread from ThreadPool");
    }

    static void DoTaskWork()
    {
        Console.WriteLine("Task is running");
    }
}

---

8. 最佳实践

• 避免线程阻塞：尽量减少线程的阻塞操作，例如使用 Thread.Sleep()。
• 使用高级抽象：尽量使用 Task 或线程池来处理并行任务，而不是手动管理 Thread。
• 正确处理线程同步：在访问共享资源时，使用 lock 或其他同步机制，确保线程安全。
• 最小化锁定范围：将锁定的代码块限制到最小范围，以避免性能瓶颈。
• 使用线程池而不是直接创建线程：线程池的开销更低，因为线程可以重用，不需要频繁创建和销毁。

---

9. 总结

C# 的多线程编程为高并发、并行处理任务提供了强大的工具。通过 Thread、ThreadPool 和 Task 等多线程机制，可以有效提高应用程序的性能和响应性。在开发过程中，务必注意线程同步问题，避免竞态条件，同时遵循最佳实践。