活动公告

系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

C#开发者必知线程与进程的区别与应用 掌握多线程编程提升程序性能与用户体验 深入理解NET框架下的并发处理机制

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

2720

科技点

3万

积分

执行版主

碾压王

积分
32881

塔罗立华奏
执行版主 发表于 2025-8-27 15:20:00 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
1. 引言

在现代软件开发中，多线程编程已成为提升应用程序性能和用户体验的关键技术。对于C#开发者而言，深入理解线程与进程的概念、区别以及在.NET框架下的并发处理机制，是构建高效、响应迅速的应用程序的基础。本文将详细探讨这些核心概念，并通过实际代码示例展示如何在C#中应用多线程编程技术。

2. 进程与线程的基本概念

2.1 进程

进程是操作系统进行资源分配和调度的基本单位，是应用程序的执行实例。每个进程都有独立的内存空间、系统资源和执行状态。在Windows系统中，当我们打开一个应用程序（如Word、浏览器等），操作系统就会创建一个进程来运行该应用程序。

进程的主要特点包括：

• 独立性：每个进程有独立的地址空间，一个进程的崩溃不会直接影响其他进程。
• 资源拥有：进程是资源拥有的基本单位，拥有独立的内存、文件句柄等资源。
• 上下文切换开销大：由于进程间的独立性，进程间的切换需要保存和恢复更多的上下文信息，因此开销较大。

在C#中，我们可以通过Process类来与系统进程进行交互：
  2. using System.Diagnostics;
  4. class ProcessExample
  5. {
  6.     static void Main()
  7.     {
  8.         // 获取当前进程
  9.         Process currentProcess = Process.GetCurrentProcess();
  10.         Console.WriteLine($"当前进程ID: {currentProcess.Id}");
  11.         Console.WriteLine($"进程名称: {currentProcess.ProcessName}");
  12.         Console.WriteLine($"启动时间: {currentProcess.StartTime}");
  13.         
  14.         // 启动一个新的进程
  15.         try
  16.         {
  17.             Process notepadProcess = new Process();
  18.             notepadProcess.StartInfo.FileName = "notepad.exe";
  19.             notepadProcess.StartInfo.Arguments = "";
  20.             notepadProcess.Start();
  21.             
  22.             Console.WriteLine($"已启动记事本进程，ID: {notepadProcess.Id}");
  23.             
  24.             // 等待用户输入后关闭进程
  25.             Console.WriteLine("按任意键关闭记事本进程...");
  26.             Console.ReadKey();
  27.             
  28.             if (!notepadProcess.HasExited)
  29.             {
  30.                 notepadProcess.CloseMainWindow();
  31.                 notepadProcess.Close();
  32.             }
  33.         }
  34.         catch (Exception ex)
  35.         {
  36.             Console.WriteLine($"启动进程时出错: {ex.Message}");
  37.         }
  38.     }
  39. }
复制代码

2.2 线程

线程是进程中的一个执行单元，是CPU调度的基本单位。一个进程可以包含多个线程，这些线程共享进程的资源，如内存空间、文件句柄等，但每个线程有独立的执行栈、程序计数器和局部变量。

线程的主要特点包括：

• 轻量级：线程的创建和切换开销远小于进程。
• 共享资源：同一进程内的线程共享进程的资源，使得线程间通信更加方便。
• 并发性：多个线程可以并发执行，提高应用程序的响应性和吞吐量。

在C#中，我们可以通过Thread类来创建和管理线程：
  2. using System;
  3. using System.Threading;
  5. class ThreadExample
  6. {
  7.     static void Main()
  8.     {
  9.         // 获取主线程信息
  10.         Thread mainThread = Thread.CurrentThread;
  11.         Console.WriteLine($"主线程ID: {mainThread.ManagedThreadId}");
  12.         
  13.         // 创建并启动一个新线程
  14.         Thread workerThread = new Thread(WorkerMethod);
  15.         workerThread.Name = "WorkerThread";
  16.         workerThread.Start();
  17.         
  18.         // 主线程继续执行
  19.         for (int i = 0; i < 5; i++)
  20.         {
  21.             Console.WriteLine($"主线程执行: {i}");
  22.             Thread.Sleep(500);
  23.         }
  24.         
  25.         // 等待工作线程完成
  26.         workerThread.Join();
  27.         Console.WriteLine("工作线程已完成，主线程退出。");
  28.     }
  29.    
  30.     static void WorkerMethod()
  31.     {
  32.         Thread currentThread = Thread.CurrentThread;
  33.         Console.WriteLine($"工作线程 {currentThread.Name} 开始执行，ID: {currentThread.ManagedThreadId}");
  34.         
  35.         for (int i = 0; i < 5; i++)
  36.         {
  37.             Console.WriteLine($"工作线程执行: {i}");
  38.             Thread.Sleep(1000);
  39.         }
  40.         
  41.         Console.WriteLine($"工作线程 {currentThread.Name} 执行完成");
  42.     }
  43. }
复制代码

3. 线程与进程的区别

理解线程与进程的区别对于多线程编程至关重要。以下是它们之间的主要区别：

3.1 资源分配

• 进程：操作系统分配资源的基本单位，每个进程有独立的地址空间、代码、数据和资源。
• 线程：CPU调度的基本单位，同一进程内的线程共享进程的资源，包括内存空间、文件句柄等。

3.2 上下文切换

• 进程：上下文切换开销大，需要保存和恢复整个进程的地址空间、寄存器状态等。
• 线程：上下文切换开销小，只需要保存和恢复线程的寄存器状态和栈信息。

3.3 通信方式

• 进程：进程间通信（IPC）需要使用特定的机制，如管道、消息队列、共享内存等，相对复杂。
• 线程：线程间通信可以直接通过共享内存进行，更加简单高效。

3.4 健壮性

• 进程：一个进程的崩溃不会影响其他进程，系统更加稳定。
• 线程：一个线程的崩溃可能导致整个进程的崩溃，稳定性相对较低。

3.5 创建和销毁

• 进程：创建和销毁的开销大，速度慢。
• 线程：创建和销毁的开销小，速度快。

下面通过一个示例来展示进程和线程在资源使用上的区别：
  2. using System;
  3. using System.Diagnostics;
  4. using System.Threading;
  6. class ProcessVsThreadExample
  7. {
  8.     static void Main()
  9.     {
  10.         Console.WriteLine("比较进程和线程的创建开销");
  11.         
  12.         // 测试创建多个进程的开销
  13.         Stopwatch processStopwatch = Stopwatch.StartNew();
  14.         for (int i = 0; i < 5; i++)
  15.         {
  16.             Process process = new Process();
  17.             process.StartInfo.FileName = "notepad.exe";
  18.             process.Start();
  19.             process.CloseMainWindow();
  20.             process.WaitForExit();
  21.         }
  22.         processStopwatch.Stop();
  23.         
  24.         Console.WriteLine($"创建5个进程耗时: {processStopwatch.ElapsedMilliseconds} 毫秒");
  25.         
  26.         // 测试创建多个线程的开销
  27.         Stopwatch threadStopwatch = Stopwatch.StartNew();
  28.         Thread[] threads = new Thread[5];
  29.         for (int i = 0; i < 5; i++)
  30.         {
  31.             threads[i] = new Thread(WorkerMethod);
  32.             threads[i].Start();
  33.         }
  34.         
  35.         // 等待所有线程完成
  36.         foreach (Thread thread in threads)
  37.         {
  38.             thread.Join();
  39.         }
  40.         threadStopwatch.Stop();
  41.         
  42.         Console.WriteLine($"创建5个线程耗时: {threadStopwatch.ElapsedMilliseconds} 毫秒");
  43.     }
  44.    
  45.     static void WorkerMethod()
  46.     {
  47.         // 模拟一些工作
  48.         Thread.Sleep(100);
  49.     }
  50. }
复制代码

4. C#中的线程处理

4.1 Thread类

System.Threading.Thread类是C#中最基本的线程操作类，它提供了创建、控制和管理线程的方法。
  2. using System;
  3. using System.Threading;
  5. class ThreadClassExample
  6. {
  7.     static void Main()
  8.     {
  9.         // 创建线程但不立即启动
  10.         Thread thread = new Thread(new ThreadStart(ExecuteTask));
  11.         
  12.         // 设置线程属性
  13.         thread.Name = "WorkerThread";
  14.         thread.IsBackground = false; // 前台线程
  15.         
  16.         // 启动线程
  17.         thread.Start();
  18.         
  19.         // 检查线程状态
  20.         Console.WriteLine($"线程状态: {thread.ThreadState}");
  21.         
  22.         // 等待线程完成
  23.         thread.Join();
  24.         Console.WriteLine("线程执行完成");
  25.     }
  26.    
  27.     static void ExecuteTask()
  28.     {
  29.         Console.WriteLine($"{Thread.CurrentThread.Name} 开始执行");
  30.         
  31.         // 模拟耗时操作
  32.         for (int i = 0; i < 5; i++)
  33.         {
  34.             Console.WriteLine($"{Thread.CurrentThread.Name} 执行中: {i}");
  35.             Thread.Sleep(500);
  36.         }
  37.         
  38.         Console.WriteLine($"{Thread.CurrentThread.Name} 执行完成");
  39.     }
  40. }
复制代码

4.2 线程池

线程池是一种基于池化思想管理线程的技术，它可以避免频繁创建和销毁线程所带来的开销。在.NET中，ThreadPool类提供了对线程池的访问。
  2. using System;
  3. using System.Threading;
  5. class ThreadPoolExample
  6. {
  7.     static void Main()
  8.     {
  9.         // 获取线程池信息
  10.         int workerThreads;
  11.         int completionPortThreads;
  12.         ThreadPool.GetMaxThreads(out workerThreads, out completionPortThreads);
  13.         Console.WriteLine($"最大工作线程数: {workerThreads}");
  14.         Console.WriteLine($"最大I/O线程数: {completionPortThreads}");
  15.         
  16.         // 使用线程池执行任务
  17.         for (int i = 0; i < 5; i++)
  18.         {
  19.             int taskNum = i;
  20.             ThreadPool.QueueUserWorkItem(state =>
  21.             {
  22.                 Console.WriteLine($"任务 {taskNum} 在线程池线程上执行，线程ID: {Thread.CurrentThread.ManagedThreadId}");
  23.                 Thread.Sleep(1000);
  24.                 Console.WriteLine($"任务 {taskNum} 完成");
  25.             });
  26.         }
  27.         
  28.         // 等待所有任务完成
  29.         Console.WriteLine("按任意键退出...");
  30.         Console.ReadKey();
  31.     }
  32. }
复制代码

4.3 Task类

.NET Framework 4引入了System.Threading.Tasks命名空间，提供了更高级的抽象来表示异步操作。Task类是任务并行库（TPL）的核心，它提供了比直接使用Thread或ThreadPool更简单、更强大的API。
  2. using System;
  3. using System.Threading;
  4. using System.Threading.Tasks;
  6. class TaskExample
  7. {
  8.     static void Main()
  9.     {
  10.         // 创建并启动一个Task
  11.         Task task1 = Task.Run(() =>
  12.         {
  13.             Console.WriteLine($"Task 1 在线程 {Thread.CurrentThread.ManagedThreadId} 上执行");
  14.             Thread.Sleep(1000);
  15.             Console.WriteLine("Task 1 完成");
  16.         });
  17.         
  18.         // 创建并启动一个带返回值的Task
  19.         Task<int> task2 = Task.Run(() =>
  20.         {
  21.             Console.WriteLine($"Task 2 在线程 {Thread.CurrentThread.ManagedThreadId} 上执行");
  22.             Thread.Sleep(1500);
  23.             return 42;
  24.         });
  25.         
  26.         // 使用ContinueWith在任务完成后继续执行
  27.         task1.ContinueWith(t =>
  28.         {
  29.             Console.WriteLine("Task 1 的后续操作");
  30.         });
  31.         
  32.         // 等待所有任务完成
  33.         Task.WaitAll(task1, task2);
  34.         
  35.         // 获取Task的结果
  36.         Console.WriteLine($"Task 2 的结果: {task2.Result}");
  37.         
  38.         // 使用Task.Factory创建任务
  39.         Task task3 = Task.Factory.StartNew(() =>
  40.         {
  41.             Console.WriteLine($"Task 3 在线程 {Thread.CurrentThread.ManagedThreadId} 上执行");
  42.             Thread.Sleep(500);
  43.             Console.WriteLine("Task 3 完成");
  44.         });
  45.         
  46.         task3.Wait();
  47.         Console.WriteLine("所有任务完成");
  48.     }
  49. }
复制代码

4.4 async/await模式

C# 5引入了async和await关键字，使得异步编程更加直观和简洁。这种模式特别适合I/O密集型操作。
  2. using System;
  3. using System.Net.Http;
  4. using System.Threading.Tasks;
  6. class AsyncAwaitExample
  7. {
  8.     static async Task Main(string[] args)
  9.     {
  10.         Console.WriteLine("开始执行异步操作");
  11.         
  12.         // 调用异步方法
  13.         string result = await DownloadContentAsync("https://www.example.com");
  14.         Console.WriteLine($"下载的内容长度: {result.Length}");
  15.         
  16.         Console.WriteLine("按任意键退出...");
  17.         Console.ReadKey();
  18.     }
  19.    
  20.     static async Task<string> DownloadContentAsync(string url)
  21.     {
  22.         using (HttpClient client = new HttpClient())
  23.         {
  24.             Console.WriteLine("开始下载内容...");
  25.             
  26.             // 异步下载内容
  27.             string content = await client.GetStringAsync(url);
  28.             
  29.             Console.WriteLine("内容下载完成");
  30.             return content;
  31.         }
  32.     }
  33. }
复制代码

5. .NET框架下的并发处理机制

5.1 同步原语

在多线程编程中，同步原语用于控制多个线程对共享资源的访问，防止数据竞争和不一致。

lock语句是C#中最简单的同步机制，用于确保代码块在同一时间只能被一个线程执行。
  2. using System;
  3. using System.Threading;
  5. class LockExample
  6. {
  7.     private static readonly object _lockObject = new object();
  8.     private static int _counter = 0;
  9.    
  10.     static void Main()
  11.     {
  12.         // 创建多个线程来增加计数器
  13.         Thread[] threads = new Thread[10];
  14.         for (int i = 0; i < threads.Length; i++)
  15.         {
  16.             threads[i] = new Thread(IncrementCounter);
  17.             threads[i].Start();
  18.         }
  19.         
  20.         // 等待所有线程完成
  21.         foreach (Thread thread in threads)
  22.         {
  23.             thread.Join();
  24.         }
  25.         
  26.         Console.WriteLine($"最终计数器值: {_counter}");
  27.     }
  28.    
  29.     static void IncrementCounter()
  30.     {
  31.         for (int i = 0; i < 1000; i++)
  32.         {
  33.             // 使用lock确保对_counter的原子操作
  34.             lock (_lockObject)
  35.             {
  36.                 _counter++;
  37.             }
  38.         }
  39.     }
  40. }
复制代码

Monitor类提供了更细粒度的控制，包括尝试获取锁而不阻塞、指定超时等。
  2. using System;
  3. using System.Threading;
  5. class MonitorExample
  6. {
  7.     private static readonly object _lockObject = new object();
  8.     private static int _sharedResource = 0;
  9.    
  10.     static void Main()
  11.     {
  12.         Thread thread1 = new Thread(() => AccessResource("Thread1"));
  13.         Thread thread2 = new Thread(() => AccessResource("Thread2"));
  14.         
  15.         thread1.Start();
  16.         thread2.Start();
  17.         
  18.         thread1.Join();
  19.         thread2.Join();
  20.         
  21.         Console.WriteLine($"最终资源值: {_sharedResource}");
  22.     }
  23.    
  24.     static void AccessResource(string threadName)
  25.     {
  26.         Console.WriteLine($"{threadName} 尝试获取锁...");
  27.         
  28.         // 尝试获取锁，最多等待1秒
  29.         if (Monitor.TryEnter(_lockObject, 1000))
  30.         {
  31.             try
  32.             {
  33.                 Console.WriteLine($"{threadName} 获取了锁，正在访问资源...");
  34.                
  35.                 // 模拟工作
  36.                 for (int i = 0; i < 5; i++)
  37.                 {
  38.                     _sharedResource++;
  39.                     Console.WriteLine($"{threadName} 更新资源为: {_sharedResource}");
  40.                     Thread.Sleep(500);
  41.                 }
  42.             }
  43.             finally
  44.             {
  45.                 // 确保锁被释放
  46.                 Monitor.Exit(_lockObject);
  47.                 Console.WriteLine($"{threadName} 释放了锁");
  48.             }
  49.         }
  50.         else
  51.         {
  52.             Console.WriteLine($"{threadName} 无法获取锁，超时");
  53.         }
  54.     }
  55. }
复制代码

Mutex（互斥体）是一种同步原语，可以用于进程间同步。
  2. using System;
  3. using System.Threading;
  5. class MutexExample
  6. {
  7.     // 创建一个命名的Mutex，可用于跨进程同步
  8.     private static Mutex _mutex = new Mutex(false, "MyNamedMutex");
  9.    
  10.     static void Main()
  11.     {
  12.         Console.WriteLine("应用程序启动，尝试获取互斥体...");
  13.         
  14.         // 尝试获取互斥体
  15.         if (_mutex.WaitOne(3000))
  16.         {
  17.             try
  18.             {
  19.                 Console.WriteLine("获取互斥体成功，执行关键操作...");
  20.                
  21.                 // 模拟关键操作
  22.                 for (int i = 0; i < 5; i++)
  23.                 {
  24.                     Console.WriteLine($"执行操作: {i + 1}/5");
  25.                     Thread.Sleep(1000);
  26.                 }
  27.             }
  28.             finally
  29.             {
  30.                 // 释放互斥体
  31.                 _mutex.ReleaseMutex();
  32.                 Console.WriteLine("互斥体已释放");
  33.             }
  34.         }
  35.         else
  36.         {
  37.             Console.WriteLine("获取互斥体失败，可能另一个实例正在运行");
  38.         }
  39.         
  40.         Console.WriteLine("按任意键退出...");
  41.         Console.ReadKey();
  42.     }
  43. }
复制代码

Semaphore（信号量）用于限制同时访问某一资源的线程数量。
  2. using System;
  3. using System.Threading;
  5. class SemaphoreExample
  6. {
  7.     // 创建一个信号量，最多允许3个线程同时访问
  8.     private static Semaphore _semaphore = new Semaphore(3, 3);
  9.    
  10.     static void Main()
  11.     {
  12.         // 创建并启动10个工作线程
  13.         for (int i = 0; i < 10; i++)
  14.         {
  15.             int threadNum = i;
  16.             Thread workerThread = new Thread(() => AccessResource(threadNum));
  17.             workerThread.Name = $"Thread {i}";
  18.             workerThread.Start();
  19.         }
  20.         
  21.         Console.WriteLine("按任意键退出...");
  22.         Console.ReadKey();
  23.     }
  24.    
  25.     static void AccessResource(int threadNum)
  26.     {
  27.         Console.WriteLine($"线程 {threadNum} 等待访问资源...");
  28.         
  29.         // 等待信号量
  30.         _semaphore.WaitOne();
  31.         
  32.         try
  33.         {
  34.             Console.WriteLine($"线程 {threadNum} 获得访问权限，正在使用资源...");
  35.             
  36.             // 模拟使用资源
  37.             Thread.Sleep(2000);
  38.             
  39.             Console.WriteLine($"线程 {threadNum} 完成资源使用");
  40.         }
  41.         finally
  42.         {
  43.             // 释放信号量
  44.             _semaphore.Release();
  45.         }
  46.     }
  47. }
复制代码

5.2 线程安全集合

.NET Framework提供了一些线程安全的集合类，用于在多线程环境中安全地操作数据。

ConcurrentDictionary是线程安全的字典集合。
  2. using System;
  3. using System.Collections.Concurrent;
  4. using System.Threading;
  5. using System.Threading.Tasks;
  7. class ConcurrentDictionaryExample
  8. {
  9.     static void Main()
  10.     {
  11.         // 创建线程安全的字典
  12.         ConcurrentDictionary<string, int> dictionary = new ConcurrentDictionary<string, int>();
  13.         
  14.         // 创建多个任务并发操作字典
  15.         Task[] tasks = new Task[10];
  16.         for (int i = 0; i < tasks.Length; i++)
  17.         {
  18.             int taskNum = i;
  19.             tasks[i] = Task.Run(() =>
  20.             {
  21.                 for (int j = 0; j < 100; j++)
  22.                 {
  23.                     string key = $"Key-{taskNum}-{j}";
  24.                     
  25.                     // 使用AddOrUpdate确保线程安全
  26.                     dictionary.AddOrUpdate(key, 1, (k, v) => v + 1);
  27.                     
  28.                     // 模拟一些工作
  29.                     Thread.Sleep(10);
  30.                 }
  31.             });
  32.         }
  33.         
  34.         // 等待所有任务完成
  35.         Task.WaitAll(tasks);
  36.         
  37.         // 输出结果
  38.         Console.WriteLine($"字典中的项数: {dictionary.Count}");
  39.         
  40.         // 检查一些特定键的值
  41.         for (int i = 0; i < 3; i++)
  42.         {
  43.             string key = $"Key-{i}-0";
  44.             if (dictionary.TryGetValue(key, out int value))
  45.             {
  46.                 Console.WriteLine($"{key} 的值: {value}");
  47.             }
  48.         }
  49.     }
  50. }
复制代码

ConcurrentQueue是线程安全的先进先出（FIFO）集合。
  2. using System;
  3. using System.Collections.Concurrent;
  4. using System.Threading;
  5. using System.Threading.Tasks;
  7. class ConcurrentQueueExample
  8. {
  9.     static void Main()
  10.     {
  11.         // 创建线程安全的队列
  12.         ConcurrentQueue<int> queue = new ConcurrentQueue<int>();
  13.         
  14.         // 创建生产者任务
  15.         Task producer = Task.Run(() =>
  16.         {
  17.             for (int i = 0; i < 100; i++)
  18.             {
  19.                 queue.Enqueue(i);
  20.                 Console.WriteLine($"生产: {i}");
  21.                 Thread.Sleep(50);
  22.             }
  23.         });
  24.         
  25.         // 创建消费者任务
  26.         Task consumer = Task.Run(() =>
  27.         {
  28.             int value;
  29.             while (true)
  30.             {
  31.                 if (queue.TryDequeue(out value))
  32.                 {
  33.                     Console.WriteLine($"消费: {value}");
  34.                     Thread.Sleep(100);
  35.                 }
  36.                 else if (producer.IsCompleted)
  37.                 {
  38.                     break;
  39.                 }
  40.             }
  41.         });
  42.         
  43.         // 等待所有任务完成
  44.         Task.WaitAll(producer, consumer);
  45.         
  46.         Console.WriteLine($"队列中的剩余项数: {queue.Count}");
  47.     }
  48. }
复制代码

5.3 并行编程

.NET Framework提供了并行编程支持，可以充分利用多核处理器的计算能力。

Parallel类提供了数据并行和任务并行的简化方法。
  2. using System;
  3. using System.Threading.Tasks;
  5. class ParallelExample
  6. {
  7.     static void Main()
  8.     {
  9.         // 使用Parallel.For进行数据并行
  10.         Console.WriteLine("Parallel.For 示例:");
  11.         Parallel.For(0, 10, i =>
  12.         {
  13.             Console.WriteLine($"迭代 {i} 在线程 {Task.CurrentId} 上执行");
  14.             Task.Delay(100).Wait(); // 模拟工作
  15.         });
  16.         
  17.         Console.WriteLine();
  18.         
  19.         // 使用Parallel.ForEach进行数据并行
  20.         Console.WriteLine("Parallel.ForEach 示例:");
  21.         string[] items = { "A", "B", "C", "D", "E" };
  22.         Parallel.ForEach(items, item =>
  23.         {
  24.             Console.WriteLine($"处理 {item} 在线程 {Task.CurrentId} 上执行");
  25.             Task.Delay(100).Wait(); // 模拟工作
  26.         });
  27.         
  28.         Console.WriteLine();
  29.         
  30.         // 使用Parallel.Invoke进行任务并行
  31.         Console.WriteLine("Parallel.Invoke 示例:");
  32.         Parallel.Invoke(
  33.             () => {
  34.                 Console.WriteLine($"任务1 在线程 {Task.CurrentId} 上执行");
  35.                 Task.Delay(500).Wait();
  36.             },
  37.             () => {
  38.                 Console.WriteLine($"任务2 在线程 {Task.CurrentId} 上执行");
  39.                 Task.Delay(300).Wait();
  40.             },
  41.             () => {
  42.                 Console.WriteLine($"任务3 在线程 {Task.CurrentId} 上执行");
  43.                 Task.Delay(400).Wait();
  44.             }
  45.         );
  46.         
  47.         Console.WriteLine("所有并行操作完成");
  48.     }
  49. }
复制代码

PLINQ是LINQ的并行实现，可以自动并行化查询操作。
  2. using System;
  3. using System.Linq;
  5. class PLINQExample
  6. {
  7.     static void Main()
  8.     {
  9.         // 创建一个大数组
  10.         int[] numbers = Enumerable.Range(1, 10000000).ToArray();
  11.         
  12.         Console.WriteLine("开始处理大数据集...");
  13.         
  14.         // 使用普通LINQ查询
  15.         var linqStartTime = DateTime.Now;
  16.         var linqResult = numbers.Where(n => n % 2 == 0)
  17.                                .Select(n => n * 2)
  18.                                .Take(100)
  19.                                .ToList();
  20.         var linqEndTime = DateTime.Now;
  21.         
  22.         Console.WriteLine($"LINQ处理时间: {(linqEndTime - linqStartTime).TotalMilliseconds} 毫秒");
  23.         
  24.         // 使用PLINQ并行查询
  25.         var plinqStartTime = DateTime.Now;
  26.         var plinqResult = numbers.AsParallel()
  27.                                 .Where(n => n % 2 == 0)
  28.                                 .Select(n => n * 2)
  29.                                 .Take(100)
  30.                                 .ToList();
  31.         var plinqEndTime = DateTime.Now;
  32.         
  33.         Console.WriteLine($"PLINQ处理时间: {(plinqEndTime - plinqStartTime).TotalMilliseconds} 毫秒");
  34.         
  35.         // 验证结果是否相同
  36.         Console.WriteLine($"结果相同: {linqResult.SequenceEqual(plinqResult)}");
  37.         
  38.         // 使用WithDegreeOfParallelism控制并行度
  39.         var controlledStartTime = DateTime.Now;
  40.         var controlledResult = numbers.AsParallel()
  41.                                      .WithDegreeOfParallelism(4) // 限制最多使用4个处理器
  42.                                      .Where(n => n % 2 == 0)
  43.                                      .Select(n => n * 2)
  44.                                      .Take(100)
  45.                                      .ToList();
  46.         var controlledEndTime = DateTime.Now;
  47.         
  48.         Console.WriteLine($"控制并行度的PLINQ处理时间: {(controlledEndTime - controlledStartTime).TotalMilliseconds} 毫秒");
  49.         
  50.         // 使用AsOrdered保持原始顺序
  51.         var orderedStartTime = DateTime.Now;
  52.         var orderedResult = numbers.AsParallel()
  53.                                  .AsOrdered() // 保持原始顺序
  54.                                  .Where(n => n % 2 == 0)
  55.                                  .Select(n => n * 2)
  56.                                  .Take(100)
  57.                                  .ToList();
  58.         var orderedEndTime = DateTime.Now;
  59.         
  60.         Console.WriteLine($"保持顺序的PLINQ处理时间: {(orderedEndTime - orderedStartTime).TotalMilliseconds} 毫秒");
  61.     }
  62. }
复制代码

6. 多线程编程的应用场景

6.1 GUI应用程序

在GUI应用程序中，使用多线程可以避免界面冻结，提高用户体验。
  2. using System;
  3. using System.Threading;
  4. using System.Threading.Tasks;
  5. using System.Windows.Forms;
  7. namespace GUIExample
  8. {
  9.     public partial class MainForm : Form
  10.     {
  11.         public MainForm()
  12.         {
  13.             InitializeComponent();
  14.         }
  15.         
  16.         private void btnProcess_Click(object sender, EventArgs e)
  17.         {
  18.             // 禁用按钮，防止重复点击
  19.             btnProcess.Enabled = false;
  20.             
  21.             // 显示进度条
  22.             progressBar.Visible = true;
  23.             progressBar.Value = 0;
  24.             
  25.             // 使用Task.Run在后台线程执行耗时操作
  26.             Task.Run(() =>
  27.             {
  28.                 for (int i = 0; i <= 100; i++)
  29.                 {
  30.                     // 模拟耗时操作
  31.                     Thread.Sleep(100);
  32.                     
  33.                     // 更新UI（必须使用Control.Invoke或Control.BeginInvoke）
  34.                     this.Invoke((MethodInvoker)delegate
  35.                     {
  36.                         progressBar.Value = i;
  37.                         lblStatus.Text = $"处理进度: {i}%";
  38.                     });
  39.                 }
  40.                
  41.                 // 操作完成后更新UI
  42.                 this.Invoke((MethodInvoker)delegate
  43.                 {
  44.                     lblStatus.Text = "处理完成!";
  45.                     btnProcess.Enabled = true;
  46.                 });
  47.             });
  48.         }
  49.     }
  50. }
复制代码

6.2 服务器应用程序

在服务器应用程序中，多线程可以同时处理多个客户端请求，提高服务器的吞吐量。
  2. using System;
  3. using System.Net;
  4. using System.Net.Sockets;
  5. using System.Text;
  6. using System.Threading;
  8. class ServerExample
  9. {
  10.     private static bool _isRunning = false;
  11.     private static TcpListener _listener;
  12.    
  13.     static void Main()
  14.     {
  15.         // 启动服务器
  16.         StartServer(8888);
  17.         
  18.         Console.WriteLine("服务器已启动，按Q键停止服务器...");
  19.         
  20.         // 等待用户输入以停止服务器
  21.         while (Console.ReadKey().Key != ConsoleKey.Q) { }
  22.         
  23.         // 停止服务器
  24.         StopServer();
  25.     }
  26.    
  27.     static void StartServer(int port)
  28.     {
  29.         _listener = new TcpListener(IPAddress.Any, port);
  30.         _listener.Start();
  31.         _isRunning = true;
  32.         
  33.         // 创建一个线程来监听客户端连接
  34.         Thread listenerThread = new Thread(() =>
  35.         {
  36.             while (_isRunning)
  37.             {
  38.                 try
  39.                 {
  40.                     // 接受客户端连接
  41.                     TcpClient client = _listener.AcceptTcpClient();
  42.                     Console.WriteLine("客户端已连接");
  43.                     
  44.                     // 为每个客户端创建一个处理线程
  45.                     Thread clientThread = new Thread(() => HandleClient(client));
  46.                     clientThread.Start();
  47.                 }
  48.                 catch (Exception ex)
  49.                 {
  50.                     Console.WriteLine($"监听错误: {ex.Message}");
  51.                 }
  52.             }
  53.         });
  54.         
  55.         listenerThread.Start();
  56.     }
  57.    
  58.     static void StopServer()
  59.     {
  60.         _isRunning = false;
  61.         _listener?.Stop();
  62.         Console.WriteLine("服务器已停止");
  63.     }
  64.    
  65.     static void HandleClient(TcpClient client)
  66.     {
  67.         try
  68.         {
  69.             using (NetworkStream stream = client.GetStream())
  70.             {
  71.                 byte[] buffer = new byte[1024];
  72.                 int bytesRead;
  73.                
  74.                 // 读取客户端发送的数据
  75.                 bytesRead = stream.Read(buffer, 0, buffer.Length);
  76.                 string clientMessage = Encoding.ASCII.GetString(buffer, 0, bytesRead);
  77.                 Console.WriteLine($"收到消息: {clientMessage}");
  78.                
  79.                 // 处理请求（模拟耗时操作）
  80.                 Thread.Sleep(1000);
  81.                
  82.                 // 发送响应
  83.                 string response = $"服务器响应: {clientMessage.ToUpper()}";
  84.                 byte[] responseBytes = Encoding.ASCII.GetBytes(response);
  85.                 stream.Write(responseBytes, 0, responseBytes.Length);
  86.                 Console.WriteLine($"已发送响应: {response}");
  87.             }
  88.         }
  89.         catch (Exception ex)
  90.         {
  91.             Console.WriteLine($"处理客户端时出错: {ex.Message}");
  92.         }
  93.         finally
  94.         {
  95.             client.Close();
  96.             Console.WriteLine("客户端连接已关闭");
  97.         }
  98.     }
  99. }
复制代码

6.3 并行计算

对于计算密集型任务，使用多线程可以充分利用多核处理器的计算能力。
  2. using System;
  3. using System.Diagnostics;
  4. using System.Threading.Tasks;
  6. class ParallelComputingExample
  7. {
  8.     static void Main()
  9.     {
  10.         // 创建大型矩阵
  11.         int size = 1000;
  12.         double[,] matrixA = GenerateRandomMatrix(size, size);
  13.         double[,] matrixB = GenerateRandomMatrix(size, size);
  14.         
  15.         // 串行矩阵乘法
  16.         var serialStopwatch = Stopwatch.StartNew();
  17.         double[,] serialResult = SerialMatrixMultiply(matrixA, matrixB);
  18.         serialStopwatch.Stop();
  19.         Console.WriteLine($"串行矩阵乘法耗时: {serialStopwatch.ElapsedMilliseconds} 毫秒");
  20.         
  21.         // 并行矩阵乘法
  22.         var parallelStopwatch = Stopwatch.StartNew();
  23.         double[,] parallelResult = ParallelMatrixMultiply(matrixA, matrixB);
  24.         parallelStopwatch.Stop();
  25.         Console.WriteLine($"并行矩阵乘法耗时: {parallelStopwatch.ElapsedMilliseconds} 毫秒");
  26.         
  27.         // 验证结果是否相同
  28.         bool resultsEqual = true;
  29.         for (int i = 0; i < size; i++)
  30.         {
  31.             for (int j = 0; j < size; j++)
  32.             {
  33.                 if (Math.Abs(serialResult[i, j] - parallelResult[i, j]) > 0.000001)
  34.                 {
  35.                     resultsEqual = false;
  36.                     break;
  37.                 }
  38.             }
  39.             if (!resultsEqual) break;
  40.         }
  41.         
  42.         Console.WriteLine($"结果相同: {resultsEqual}");
  43.         Console.WriteLine($"加速比: {(double)serialStopwatch.ElapsedMilliseconds / parallelStopwatch.ElapsedMilliseconds:F2}x");
  44.     }
  45.    
  46.     // 生成随机矩阵
  47.     static double[,] GenerateRandomMatrix(int rows, int cols)
  48.     {
  49.         double[,] matrix = new double[rows, cols];
  50.         Random random = new Random();
  51.         
  52.         for (int i = 0; i < rows; i++)
  53.         {
  54.             for (int j = 0; j < cols; j++)
  55.             {
  56.                 matrix[i, j] = random.NextDouble() * 100;
  57.             }
  58.         }
  59.         
  60.         return matrix;
  61.     }
  62.    
  63.     // 串行矩阵乘法
  64.     static double[,] SerialMatrixMultiply(double[,] matrixA, double[,] matrixB)
  65.     {
  66.         int aRows = matrixA.GetLength(0);
  67.         int aCols = matrixA.GetLength(1);
  68.         int bCols = matrixB.GetLength(1);
  69.         
  70.         double[,] result = new double[aRows, bCols];
  71.         
  72.         for (int i = 0; i < aRows; i++)
  73.         {
  74.             for (int j = 0; j < bCols; j++)
  75.             {
  76.                 for (int k = 0; k < aCols; k++)
  77.                 {
  78.                     result[i, j] += matrixA[i, k] * matrixB[k, j];
  79.                 }
  80.             }
  81.         }
  82.         
  83.         return result;
  84.     }
  85.    
  86.     // 并行矩阵乘法
  87.     static double[,] ParallelMatrixMultiply(double[,] matrixA, double[,] matrixB)
  88.     {
  89.         int aRows = matrixA.GetLength(0);
  90.         int aCols = matrixA.GetLength(1);
  91.         int bCols = matrixB.GetLength(1);
  92.         
  93.         double[,] result = new double[aRows, bCols];
  94.         
  95.         // 使用Parallel.For并行计算
  96.         Parallel.For(0, aRows, i =>
  97.         {
  98.             for (int j = 0; j < bCols; j++)
  99.             {
  100.                 for (int k = 0; k < aCols; k++)
  101.                 {
  102.                     result[i, j] += matrixA[i, k] * matrixB[k, j];
  103.                 }
  104.             }
  105.         });
  106.         
  107.         return result;
  108.     }
  109. }
复制代码

7. 多线程编程的最佳实践

7.1 避免死锁

死锁是多线程编程中的常见问题，当两个或多个线程互相等待对方释放资源时，就会发生死锁。
  2. using System;
  3. using System.Threading;
  5. class DeadlockExample
  6. {
  7.     private static readonly object _lock1 = new object();
  8.     private static readonly object _lock2 = new object();
  9.    
  10.     static void Main()
  11.     {
  12.         // 创建两个线程，它们以不同的顺序获取锁
  13.         Thread thread1 = new Thread(() =>
  14.         {
  15.             Console.WriteLine("线程1: 尝试获取lock1...");
  16.             lock (_lock1)
  17.             {
  18.                 Console.WriteLine("线程1: 获取了lock1");
  19.                 Thread.Sleep(100); // 增加死锁发生的概率
  20.                
  21.                 Console.WriteLine("线程1: 尝试获取lock2...");
  22.                 lock (_lock2)
  23.                 {
  24.                     Console.WriteLine("线程1: 获取了lock1和lock2");
  25.                 }
  26.             }
  27.         });
  28.         
  29.         Thread thread2 = new Thread(() =>
  30.         {
  31.             Console.WriteLine("线程2: 尝试获取lock2...");
  32.             lock (_lock2)
  33.             {
  34.                 Console.WriteLine("线程2: 获取了lock2");
  35.                 Thread.Sleep(100); // 增加死锁发生的概率
  36.                
  37.                 Console.WriteLine("线程2: 尝试获取lock1...");
  38.                 lock (_lock1)
  39.                 {
  40.                     Console.WriteLine("线程2: 获取了lock1和lock2");
  41.                 }
  42.             }
  43.         });
  44.         
  45.         thread1.Start();
  46.         thread2.Start();
  47.         
  48.         // 设置超时，防止程序无限期等待
  49.         if (!thread1.Join(5000))
  50.         {
  51.             Console.WriteLine("线程1可能已死锁");
  52.         }
  53.         
  54.         if (!thread2.Join(5000))
  55.         {
  56.             Console.WriteLine("线程2可能已死锁");
  57.         }
  58.         
  59.         Console.WriteLine("主线程退出");
  60.     }
  61. }
复制代码

避免死锁的最佳实践：

1. 始终以相同的顺序获取多个锁。
2. 使用Monitor.TryEnter而不是lock语句，并指定超时。
3. 尽量减少锁的持有时间。
4. 使用更高级的同步机制，如Mutex、Semaphore等。

7.2 减少锁的粒度

锁的粒度指的是被锁保护的代码范围或数据范围。减少锁的粒度可以提高并发性能。
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Threading;
  5. using System.Threading.Tasks;
  7. class LockGranularityExample
  8. {
  9.     // 粗粒度锁示例
  10.     class CoarseGrainedBankAccount
  11.     {
  12.         private readonly object _lock = new object();
  13.         private decimal _balance;
  14.         private List<string> _transactionHistory = new List<string>();
  15.         
  16.         public void Deposit(decimal amount)
  17.         {
  18.             lock (_lock)
  19.             {
  20.                 _balance += amount;
  21.                 _transactionHistory.Add($"存款: +{amount}");
  22.             }
  23.         }
  24.         
  25.         public void Withdraw(decimal amount)
  26.         {
  27.             lock (_lock)
  28.             {
  29.                 _balance -= amount;
  30.                 _transactionHistory.Add($"取款: -{amount}");
  31.             }
  32.         }
  33.         
  34.         public decimal GetBalance()
  35.         {
  36.             lock (_lock)
  37.             {
  38.                 return _balance;
  39.             }
  40.         }
  41.         
  42.         public List<string> GetTransactionHistory()
  43.         {
  44.             lock (_lock)
  45.             {
  46.                 return new List<string>(_transactionHistory);
  47.             }
  48.         }
  49.     }
  50.    
  51.     // 细粒度锁示例
  52.     class FineGrainedBankAccount
  53.     {
  54.         private readonly object _balanceLock = new object();
  55.         private readonly object _historyLock = new object();
  56.         private decimal _balance;
  57.         private List<string> _transactionHistory = new List<string>();
  58.         
  59.         public void Deposit(decimal amount)
  60.         {
  61.             lock (_balanceLock)
  62.             {
  63.                 _balance += amount;
  64.             }
  65.             
  66.             lock (_historyLock)
  67.             {
  68.                 _transactionHistory.Add($"存款: +{amount}");
  69.             }
  70.         }
  71.         
  72.         public void Withdraw(decimal amount)
  73.         {
  74.             lock (_balanceLock)
  75.             {
  76.                 _balance -= amount;
  77.             }
  78.             
  79.             lock (_historyLock)
  80.             {
  81.                 _transactionHistory.Add($"取款: -{amount}");
  82.             }
  83.         }
  84.         
  85.         public decimal GetBalance()
  86.         {
  87.             lock (_balanceLock)
  88.             {
  89.                 return _balance;
  90.             }
  91.         }
  92.         
  93.         public List<string> GetTransactionHistory()
  94.         {
  95.             lock (_historyLock)
  96.             {
  97.                 return new List<string>(_transactionHistory);
  98.             }
  99.         }
  100.     }
  101.    
  102.     static void Main()
  103.     {
  104.         // 测试粗粒度锁的性能
  105.         var coarseAccount = new CoarseGrainedBankAccount();
  106.         var coarseStopwatch = System.Diagnostics.Stopwatch.StartNew();
  107.         
  108.         Parallel.For(0, 10000, i =>
  109.         {
  110.             if (i % 2 == 0)
  111.             {
  112.                 coarseAccount.Deposit(100);
  113.             }
  114.             else
  115.             {
  116.                 coarseAccount.Withdraw(50);
  117.             }
  118.         });
  119.         
  120.         coarseStopwatch.Stop();
  121.         Console.WriteLine($"粗粒度锁耗时: {coarseStopwatch.ElapsedMilliseconds} 毫秒");
  122.         Console.WriteLine($"最终余额: {coarseAccount.GetBalance()}");
  123.         
  124.         // 测试细粒度锁的性能
  125.         var fineAccount = new FineGrainedBankAccount();
  126.         var fineStopwatch = System.Diagnostics.Stopwatch.StartNew();
  127.         
  128.         Parallel.For(0, 10000, i =>
  129.         {
  130.             if (i % 2 == 0)
  131.             {
  132.                 fineAccount.Deposit(100);
  133.             }
  134.             else
  135.             {
  136.                 fineAccount.Withdraw(50);
  137.             }
  138.         });
  139.         
  140.         fineStopwatch.Stop();
  141.         Console.WriteLine($"细粒度锁耗时: {fineStopwatch.ElapsedMilliseconds} 毫秒");
  142.         Console.WriteLine($"最终余额: {fineAccount.GetBalance()}");
  143.         
  144.         Console.WriteLine($"性能提升: {(double)coarseStopwatch.ElapsedMilliseconds / fineStopwatch.ElapsedMilliseconds:F2}x");
  145.     }
  146. }
复制代码

7.3 使用不可变类型

不可变对象一旦创建就不能被修改，因此在多线程环境中使用不可变类型可以避免同步问题。
  2. using System;
  3. using System.Collections.Concurrent;
  4. using System.Collections.Immutable;
  5. using System.Threading;
  6. using System.Threading.Tasks;
  8. class ImmutableExample
  9. {
  10.     // 可变类型示例
  11.     class MutablePerson
  12.     {
  13.         public string Name { get; set; }
  14.         public int Age { get; set; }
  15.         
  16.         public MutablePerson(string name, int age)
  17.         {
  18.             Name = name;
  19.             Age = age;
  20.         }
  21.     }
  22.    
  23.     // 不可变类型示例
  24.     class ImmutablePerson
  25.     {
  26.         public string Name { get; }
  27.         public int Age { get; }
  28.         
  29.         public ImmutablePerson(string name, int age)
  30.         {
  31.             Name = name;
  32.             Age = age;
  33.         }
  34.         
  35.         // 返回一个新的不可变对象，而不是修改当前对象
  36.         public ImmutablePerson WithName(string name)
  37.         {
  38.             return new ImmutablePerson(name, Age);
  39.         }
  40.         
  41.         public ImmutablePerson WithAge(int age)
  42.         {
  43.             return new ImmutablePerson(Name, age);
  44.         }
  45.     }
  46.    
  47.     static void Main()
  48.     {
  49.         // 使用可变类型的线程安全问题
  50.         Console.WriteLine("可变类型示例:");
  51.         var mutablePerson = new MutablePerson("Alice", 30);
  52.         var mutableResults = new ConcurrentBag<string>();
  53.         
  54.         Parallel.For(0, 10000, i =>
  55.         {
  56.             // 读取和修改可变对象
  57.             string name = mutablePerson.Name;
  58.             int age = mutablePerson.Age;
  59.             
  60.             // 模拟一些处理
  61.             Thread.Sleep(1);
  62.             
  63.             // 更新对象（可能导致竞争条件）
  64.             mutablePerson.Name = $"{name}_{i}";
  65.             mutablePerson.Age = age + 1;
  66.             
  67.             if (i % 1000 == 0)
  68.             {
  69.                 mutableResults.Add($"迭代 {i}: Name={mutablePerson.Name}, Age={mutablePerson.Age}");
  70.             }
  71.         });
  72.         
  73.         Console.WriteLine($"最终结果: Name={mutablePerson.Name}, Age={mutablePerson.Age}");
  74.         
  75.         // 使用不可变类型的线程安全示例
  76.         Console.WriteLine("\n不可变类型示例:");
  77.         var immutablePerson = new ImmutablePerson("Bob", 30);
  78.         var immutableResults = new ConcurrentBag<string>();
  79.         
  80.         Parallel.For(0, 10000, i =>
  81.         {
  82.             // 读取不可变对象
  83.             string name = immutablePerson.Name;
  84.             int age = immutablePerson.Age;
  85.             
  86.             // 模拟一些处理
  87.             Thread.Sleep(1);
  88.             
  89.             // 创建新的不可变对象，而不是修改现有对象
  90.             immutablePerson = immutablePerson.WithName($"{name}_{i}").WithAge(age + 1);
  91.             
  92.             if (i % 1000 == 0)
  93.             {
  94.                 immutableResults.Add($"迭代 {i}: Name={immutablePerson.Name}, Age={immutablePerson.Age}");
  95.             }
  96.         });
  97.         
  98.         Console.WriteLine($"最终结果: Name={immutablePerson.Name}, Age={immutablePerson.Age}");
  99.         
  100.         // 使用.NET的不可变集合
  101.         Console.WriteLine("\n不可变集合示例:");
  102.         var immutableList = ImmutableList<int>.Empty;
  103.         var immutableListResults = new ConcurrentBag<string>();
  104.         
  105.         Parallel.For(0, 10000, i =>
  106.         {
  107.             // 创建新的不可变集合，而不是修改现有集合
  108.             immutableList = immutableList.Add(i);
  109.             
  110.             if (i % 1000 == 0)
  111.             {
  112.                 immutableListResults.Add($"迭代 {i}: 集合大小={immutableList.Count}");
  113.             }
  114.         });
  115.         
  116.         Console.WriteLine($"最终集合大小: {immutableList.Count}");
  117.     }
  118. }
复制代码

7.4 避免不必要的线程同步

线程同步会带来性能开销，因此应尽量避免不必要的同步。
  2. using System;
  3. using System.Collections.Concurrent;
  4. using System.Threading;
  5. using System.Threading.Tasks;
  7. class UnnecessarySynchronizationExample
  8. {
  9.     // 不必要的同步示例
  10.     class UnnecessarySyncCounter
  11.     {
  12.         private readonly object _lock = new object();
  13.         private int _count;
  14.         
  15.         public void Increment()
  16.         {
  17.             // 每个线程操作自己的局部变量，不需要同步
  18.             int localCount = 0;
  19.             for (int i = 0; i < 1000; i++)
  20.             {
  21.                 localCount++;
  22.             }
  23.             
  24.             // 只在最后需要更新共享状态时才同步
  25.             lock (_lock)
  26.             {
  27.                 _count += localCount;
  28.             }
  29.         }
  30.         
  31.         public int GetCount()
  32.         {
  33.             lock (_lock)
  34.             {
  35.                 return _count;
  36.             }
  37.         }
  38.     }
  39.    
  40.     // 使用线程局部存储避免同步
  41.     class ThreadLocalCounter
  42.     {
  43.         private int _count;
  44.         
  45.         // 每个线程有自己的计数器实例
  46.         private readonly ThreadLocal<int> _threadLocalCount =
  47.             new ThreadLocal<int>(() => 0);
  48.         
  49.         public void Increment()
  50.         {
  51.             // 使用线程局部变量，无需同步
  52.             for (int i = 0; i < 1000; i++)
  53.             {
  54.                 _threadLocalCount.Value++;
  55.             }
  56.         }
  57.         
  58.         public int GetCount()
  59.         {
  60.             // 汇总所有线程的计数
  61.             // 在实际应用中，可能需要更复杂的同步机制来确保一致性
  62.             return _count + _threadLocalCount.Value;
  63.         }
  64.     }
  65.    
  66.     // 使用并发集合避免同步
  67.     class ConcurrentCollectionCounter
  68.     {
  69.         private readonly ConcurrentBag<int> _counts = new ConcurrentBag<int>();
  70.         
  71.         public void Increment()
  72.         {
  73.             // 每个线程操作自己的局部变量
  74.             int localCount = 0;
  75.             for (int i = 0; i < 1000; i++)
  76.             {
  77.                 localCount++;
  78.             }
  79.             
  80.             // 使用线程安全的集合添加结果
  81.             _counts.Add(localCount);
  82.         }
  83.         
  84.         public int GetCount()
  85.         {
  86.             // 计算总和
  87.             int total = 0;
  88.             foreach (int count in _counts)
  89.             {
  90.                 total += count;
  91.             }
  92.             return total;
  93.         }
  94.     }
  95.    
  96.     static void Main()
  97.     {
  98.         // 测试不必要的同步
  99.         var unnecessarySync = new UnnecessarySyncCounter();
  100.         var unnecessarySyncStopwatch = System.Diagnostics.Stopwatch.StartNew();
  101.         
  102.         Parallel.For(0, 10000, i =>
  103.         {
  104.             unnecessarySync.Increment();
  105.         });
  106.         
  107.         unnecessarySyncStopwatch.Stop();
  108.         Console.WriteLine($"不必要的同步耗时: {unnecessarySyncStopwatch.ElapsedMilliseconds} 毫秒");
  109.         Console.WriteLine($"计数结果: {unnecessarySync.GetCount()}");
  110.         
  111.         // 测试线程局部存储
  112.         var threadLocalCounter = new ThreadLocalCounter();
  113.         var threadLocalStopwatch = System.Diagnostics.Stopwatch.StartNew();
  114.         
  115.         Parallel.For(0, 10000, i =>
  116.         {
  117.             threadLocalCounter.Increment();
  118.         });
  119.         
  120.         threadLocalStopwatch.Stop();
  121.         Console.WriteLine($"线程局部存储耗时: {threadLocalStopwatch.ElapsedMilliseconds} 毫秒");
  122.         Console.WriteLine($"计数结果: {threadLocalCounter.GetCount()}");
  123.         
  124.         // 测试并发集合
  125.         var concurrentCounter = new ConcurrentCollectionCounter();
  126.         var concurrentStopwatch = System.Diagnostics.Stopwatch.StartNew();
  127.         
  128.         Parallel.For(0, 10000, i =>
  129.         {
  130.             concurrentCounter.Increment();
  131.         });
  132.         
  133.         concurrentStopwatch.Stop();
  134.         Console.WriteLine($"并发集合耗时: {concurrentStopwatch.ElapsedMilliseconds} 毫秒");
  135.         Console.WriteLine($"计数结果: {concurrentCounter.GetCount()}");
  136.     }
  137. }
复制代码

7.5 使用CancellationToken取消长时间运行的操作

在多线程编程中，能够取消长时间运行的操作是一项重要功能。
  2. using System;
  3. using System.Threading;
  4. using System.Threading.Tasks;
  6. class CancellationExample
  7. {
  8.     static void Main()
  9.     {
  10.         // 创建CancellationTokenSource
  11.         using (var cts = new CancellationTokenSource())
  12.         {
  13.             // 注册回调，在取消时执行
  14.             cts.Token.Register(() =>
  15.             {
  16.                 Console.WriteLine("操作已被取消");
  17.             });
  18.             
  19.             // 启动一个可取消的任务
  20.             Task longRunningTask = Task.Run(() => LongRunningOperation(cts.Token), cts.Token);
  21.             
  22.             Console.WriteLine("按C键取消操作，按其他键等待操作完成...");
  23.             
  24.             // 等待用户输入
  25.             if (Console.ReadKey().Key == ConsoleKey.C)
  26.             {
  27.                 // 取消操作
  28.                 cts.Cancel();
  29.             }
  30.             
  31.             try
  32.             {
  33.                 // 等待任务完成
  34.                 longRunningTask.Wait();
  35.             }
  36.             catch (AggregateException ex)
  37.             {
  38.                 foreach (var innerEx in ex.InnerExceptions)
  39.                 {
  40.                     if (innerEx is TaskCanceledException)
  41.                     {
  42.                         Console.WriteLine("任务被成功取消");
  43.                     }
  44.                     else
  45.                     {
  46.                         Console.WriteLine($"任务出错: {innerEx.Message}");
  47.                     }
  48.                 }
  49.             }
  50.         }
  51.         
  52.         Console.WriteLine("主线程退出");
  53.     }
  54.    
  55.     static void LongRunningOperation(CancellationToken cancellationToken)
  56.     {
  57.         Console.WriteLine("长时间运行的操作开始");
  58.         
  59.         try
  60.         {
  61.             for (int i = 0; i < 100; i++)
  62.             {
  63.                 // 检查是否已请求取消
  64.                 if (cancellationToken.IsCancellationRequested)
  65.                 {
  66.                     // 抛出OperationCanceledException
  67.                     cancellationToken.ThrowIfCancellationRequested();
  68.                 }
  69.                
  70.                 Console.WriteLine($"处理中: {i + 1}/100");
  71.                 Thread.Sleep(100);
  72.             }
  73.             
  74.             Console.WriteLine("长时间运行的操作完成");
  75.         }
  76.         catch (OperationCanceledException)
  77.         {
  78.             // 清理资源
  79.             Console.WriteLine("清理资源...");
  80.             Thread.Sleep(500);
  81.             
  82.             // 重新抛出异常
  83.             throw;
  84.         }
  85.     }
  86. }
复制代码

8. 总结

本文详细探讨了C#中线程与进程的概念、区别以及多线程编程的应用。我们了解了.NET框架下的并发处理机制，包括同步原语、线程安全集合、并行编程等。通过丰富的代码示例，我们展示了如何在实际开发中应用这些技术来提升程序性能和用户体验。

多线程编程是一项复杂但强大的技术，正确使用它可以显著提高应用程序的性能和响应能力。然而，它也带来了许多挑战，如线程安全、死锁、竞争条件等。遵循最佳实践，如减少锁的粒度、使用不可变类型、避免不必要的同步等，可以帮助我们构建更健壮、更高效的多线程应用程序。

随着.NET框架的不断发展，新的并发编程模式和API不断涌现，如Task Parallel Library (TPL)、Parallel LINQ (PLINQ)、async/await模式等，这些技术使得并发编程变得更加简单和直观。作为C#开发者，掌握这些技术并深入理解其背后的原理，将有助于我们构建更加高效、可靠的应用程序。
浏览器
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则