ToB企服应用市场:ToB评测及商务社交产业平台

标题: C# 多线程 [打印本页]

---

作者: 数据人与超自然意识    时间: 2024-7-19 20:04
标题: C# 多线程
C# 多线程编程基本概念

1. 线程（Thread）

• 定义：线程是CPU调理和分派的基本单位，是进程中的一条执行路径。
  
• 管理：在C#中，可以利用System.Threading.Thread类来创建和管理线程。
  

2. 进程（Process）

• 定义：进程是系统举行资源分配和调理的一个独立单位，是应用步伐的一次动态执行过程。
  
• 关系：一个进程可以拥有多个线程，这些线程共享进程的地址空间和系统资源。
  

3. 并发与并行

• 并发（Concurrency）：两个或多个使命在同一时间段内瓜代执行，但不一定在同一时刻执行。
  
• 并行（Parallelism）：两个或多个使命在同一时刻同时执行，通常需要多个处理器核心。
  

4. 线程同步与互斥

• 目标：确保多个线程安全地访问共享资源。
  
• 机制：锁（Locks）、互斥量（Mutexes）、信号量（Semaphores）、监视器（Monitors）、条件变量（Condition Variables）等。
  

5. Task 与 Task Parallel Library (TPL)

• Task：代表一个异步操作，提供灵活的方式来编写异步代码。
  
• TPL：提供丰富的API支持并行编程，如Parallel.For、Parallel.ForEach等。
  

6. Async/Await

• 引入：C# 5.0 引入，基于使命的异步编程模式。
  
• 特点：使异步代码看起来像同步代码，不会阻塞调用线程。
  

7. 线程池（Thread Pool）

• 定义：基于池化技能的线程管理方式，减少线程创建和销毁的开销。
  
• 利用：通过System.Threading.ThreadPool类访问。
  

8. 上下文切换

• 定义：CPU从一个线程切换到另一个线程的过程。
  
• 影响：上下文切换是昂贵的操作，会消耗CPU时间并大概导致缓存失效。
  

9. 死锁与活锁

• 死锁（Deadlock）：两个或多个线程相互等待对方释放资源而无法继续执行。
  
• 活锁（Livelock）：线程不停尝试执行操作但无法成功，通常由于错误的同步策略导致。
  

10. 线程安全

• 定义：多线程执行时，步伐的执行效果符合预期，不受并发执行的影响。
  
• 实现：通过同步机制、无锁算法或线程局部变量来减少共享资源的依赖。
  

---

线程同步

1. lock 关键字

lock 关键字用于确保一次只有一个线程可以执行某个代码块。它通常用于保护共享资源或代码段。

1. private readonly object lockObject = new object();
3. public void Method()
4. {
5.     lock (lockObject)
6.     {
7.         // 访问或修改共享资源
8.         Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 进入锁");
9.         // 模拟长时间操作
10.         Thread.Sleep(1000);
11.         Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 离开锁");
12.     }
13. }

复制代码

2. Monitor 类

Monitor 类提供了与 lock 关键字类似的功能，但提供了更多的灵活性，如尝试获取锁、释放锁等。

1. private readonly object lockObject = new object();
3. public void Method()
4. {
5.     bool lockTaken = false;
6.     try
7.     {
8.         Monitor.TryEnter(lockObject, 1000, ref lockTaken);
9.         if (lockTaken)
10.         {
11.             // 访问或修改共享资源
12.             Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 获取锁");
13.             Thread.Sleep(1000);
14.         }
15.         else
16.         {
17.             Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 未能获取锁");
18.         }
19.     }
20.     finally
21.     {
22.         if (lockTaken)
23.         {
24.             Monitor.Exit(lockObject);
25.         }
26.     }
27. }

复制代码

3. Mutex 类

Mutex 是一种跨进程的同步基元，但也可以用于同一进程内的线程同步。

1. private static Mutex mutex = new Mutex();
3. public static void Method()
4. {
5.     mutex.WaitOne();
6.     try
7.     {
8.         // 访问或修改共享资源
9.         Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 进入 Mutex");
10.         Thread.Sleep(1000);
11.     }
12.     finally
13.     {
14.         mutex.ReleaseMutex();
15.     }
16. }

复制代码

4. Semaphore 类

Semaphore 用于控制对共享资源的并发访问数目。

1. private static Semaphore semaphore = new Semaphore(1, 1); // 允许一个线程访问
3. public void Method()
4. {
5.     semaphore.WaitOne();
6.     try
7.     {
8.         // 访问或修改共享资源
9.         Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 进入 Semaphore");
10.         Thread.Sleep(1000);
11.     }
12.     finally
13.     {
14.         semaphore.Release();
15.     }
16. }

复制代码

5. Interlocked 类

Interlocked 类提供了一组静态方法，用于对变量执行简单的原子操作，如递增、递减、比较并交换等。

1. private int counter = 0;
3. public void Increment()
4. {
5.     Interlocked.Increment(ref counter);
6. }
8. public void PrintCounter()
9. {
10.     Console.WriteLine("Counter: " + Interlocked.Read(ref counter));
11. }

复制代码

6. ReaderWriterLockSlim 类

ReaderWriterLockSlim 允很多个线程同时读取共享资源，但写入操作是独占的。

1. private ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();
3. public void Read()
4. {
5.     rwLock.EnterReadLock();
6.     try
7.     {
8.         // 读取共享资源
9.         Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 正在读取");
10.         Thread.Sleep(1000);
11.     }
12.     finally
13.     {
14.         rwLock.ExitReadLock();
15.     }
16. }
18. public void Write()
19. {
20.     rwLock.EnterWriteLock();
21.     try
22.     {
23.         // 修改共享资源
24.         Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 正在写入");
25.         Thread.Sleep(1000);
26.     }
27.     finally
28.     {
29.         rwLock.ExitWriteLock();
30.     }
31. }

复制代码

7. SpinLock 类

SpinLock 是一种低延迟的锁，适用于预计锁持偶然间非常短的场景。它会让等待锁的线程举行“自旋”，即在一个循环中重复检查锁是否可用，而不是将线程挂起。这减少了线程上下文切换的开销，但也大概增长CPU的利用率。

1. private SpinLock spinLock = new SpinLock();
3. public void Method()
4. {
5.     bool lockTaken = false;
6.     try
7.     {
8.         spinLock.Enter(ref lockTaken);
9.         if (lockTaken)
10.         {
11.             // 访问或修改共享资源
12.             Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 进入 SpinLock");
13.             Thread.Sleep(100); // 假设这是一个非常快的操作
14.         }
15.     }
16.     finally
17.     {
18.         if (lockTaken)
19.         {
20.             spinLock.Exit();
21.         }
22.     }
23. }

复制代码

8. SemaphoreSlim 类

SemaphoreSlim 是 Semaphore 的一个轻量级版本，专为等待时间较短的场景筹划。它提供了异步等待的能力，非常适合在基于使命的异步编程模式（TAP）中利用。

1. private SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1); // 允许一个线程同时访问
3. public async Task MethodAsync()
4. {
5.     await semaphoreSlim.WaitAsync();
6.     try
7.     {
8.         // 访问或修改共享资源
9.         Console.WriteLine("线程 " + Thread.CurrentThread.ManagedThreadId + " 进入 SemaphoreSlim");
10.         await Task.Delay(1000); // 模拟异步操作
11.     }
12.     finally
13.     {
14.         semaphoreSlim.Release();
15.     }
16. }

复制代码

9. Barrier 类

Barrier 用于在并行算法中同步线程，确保全部线程都到达某个公共屏蔽点之后才能继续执行。这对于需要将使命分解为多个阶段，而且每个阶段都需要全部线程完成后才能继续的场景很有用。

1. private Barrier barrier = new Barrier(3); // 假设有三个线程
3. public void ThreadMethod(int threadId)
4. {
5.     Console.WriteLine($"线程 {threadId} 到达屏障 1");
6.     barrier.SignalAndWait(); // 所有线程都必须调用这个方法来等待其他线程
8.     // 执行一些工作
9.     Console.WriteLine($"线程 {threadId} 完成工作");
11.     // 可以在屏障上设置回调，当所有线程都到达时执行
12.     barrier.PostPhaseAction += (b) =>
13.     {
14.         Console.WriteLine("所有线程都到达屏障 1，继续执行...");
15.     };
17.     // 假设还有一个屏障点
18.     Console.WriteLine($"线程 {threadId} 到达屏障 2");
19.     barrier.SignalAndWait();
20. }

复制代码

留意：上面的 Barrier 示例中，由于 Barrier 的构造函数只定义了参与者的数目，并没有现实的“屏蔽点”概念（除了初始化时的那一次）。在现实应用中，你大概需要多次调用 SignalAndWait 来表现不同的同步点。此外，PostPhaseAction 回调是在每个阶段的全部线程都调用 SignalAndWait 后执行的。
10. CountdownEvent 类

CountdownEvent 允许一个或多个线程等待直到一组操作中的指定数目完成。它对于等待多个并行使命完成并继续执行下一个使命的场景非常有用。

1. private CountdownEvent countdownEvent = new CountdownEvent(3); // 初始化为3，表示有3个任务需要完成
3. public void TaskMethod(int taskId)
4. {
5.     // 执行一些工作
6.     Console.WriteLine($"任务 {taskId} 开始执行");
7.     Thread.Sleep(1000); // 模拟耗时操作
9.     // 任务完成，信号量减一
10.     countdownEvent.Signal();
12.     Console.WriteLine($"任务 {taskId} 完成");
13. }
15. public void StartTasks()
16. {
17.     for (int i = 1; i <= 3; i++)
18.     {
19.         Task.Run(() => TaskMethod(i));
20.     }
22.     // 等待所有任务完成
23.     countdownEvent.Wait();
24.     Console.WriteLine("所有任务完成");
25. }

复制代码

---

并发编程最佳实践与优化

在并发编程中，有用地管理线程和同步机制是确保步伐性能、稳定性和可扩展性的关键。以下是并发编程中的一些最佳实践、优化策略以及重要考量因素，旨在资助您构建高效且可靠的并发系统。
1. 并发聚集的利用

• 优势：System.Collections.Concurrent 命名空间提供了一系列线程安全的聚集类，如 ConcurrentDictionary<TKey, TValue>、ConcurrentQueue<T> 等。这些聚集内部实现了高效的线程安全机制，无需外部同步即可安全地在多线程情况中利用。
  

2. 优化锁的利用

• 减少锁的粒度：通过锁定尽大概小的数据范围来减少线程等待时间。
  
• 利用读写锁（ReaderWriterLockSlim）：对于读多写少的场景，读写锁可以明显进步性能，因为它允很多个读操作同时举行，而写操作会独占访问权。
  
• 制止长时间持有锁：只在须要时持有锁，并在操作完成后尽快释放，以减少对其他线程的阻塞。
  

3. 制止死锁

• 锁定序次：确保全部线程以相同的序次获取锁，以预防死锁的发生。
  
• 制止嵌套锁：减少锁的嵌套利用，简化锁的依赖关系。
  
• 利用超时：在尝试获取锁时设置超时时间，制止无穷期等待。
  

4. 异步编程（async 和 await）

• 进步响应性：async 和 await 使得异步操作看起来和同步操作一样简单，允许在等待异步操作时释放线程，从而进步应用步伐的响应性和吞吐量。
  
• 留意：在异步方法中访问共享资源时，仍需利用得当的同步机制来保护数据一致性。
  

5. 性能考量

• 线程开销：公道控制线程数目，制止过多线程导致的上下文切换开销。
  
• 资源竞争：通过优化锁的利用和减少共享资源来低落资源竞争。
  

6. 非常处理

• 确保健壮性：在并发情况中，每个线程都应能妥善处理非常，制止非常传播导致整个进程瓦解。
  

7. 调试与监控

• 调试技巧：利用断点、日记记录和并发可视化工具等调试多线程步伐。
  
• 性能分析工具：利用Visual Studio的性能分析器来辨认线程同步相干的瓶颈，并优化性能。
  
• 并发可视化：借助并发可视化工具理解线程间的交互和潜在的并发问题。
  

8. 最佳实践

• 最小化共享状态：减少线程之间的共享数据量，低落同步的复杂性和开销。
  
• 制止共享可变状态：尽量利用不可变对象或确保对象在创建后不再更改。
  
• 利用消息传递：通过消息传递机制实现线程间的通讯，减少直接共享状态的需要。
  

9. 谨慎利用线程池

• 公道设置：根据现实情况设置线程池的巨细，制止资源耗尽和性能降落。
  
• 使命调理：公道利用 Task 和 TaskScheduler 举行使命的调理和管理。
  

---

异步编程模式

极大地简化了异步代码的编写和理解，使得开发者能够以类似于同步代码的方式来编写异步逻辑，而无需深入底层的线程管理或回调机制。async 和 await 关键字是 C# 5.0 引入的两个非常重要的关键字，它们一起工作，使得异步编程变得简单和直观。
async 关键字

• async 关键字用于标记一个方法、lambda 表达式、匿名方法或局部方法作为异步方法。这告诉编译器该方法内部可以利用 await 关键字。
  
• 异步方法会隐式返回一个 Task 或 Task<T> 对象。如果方法没有返回值（即返回类型为 void），则它应该用于事件处理步伐，并应该制止在库或框架代码中利用，因为 void 返回类型的方法无法等待或捕获非常。
  

await 关键字

• await 关键字用于等待异步操作的完成。它只能用在被 async 修饰的方法内部。
  
• 当编译器看到 await 表达式时，它会将方法的别的部分安排在 await 表达式表现的异步操作完成后继续执行。在等待期间，控制权会返回给方法的调用者，允许调用者继续执行其他操作，而不是阻塞等待异步操作的完成。
  
• await 表达式的效果是异步操作的效果。如果操作返回 Task<T>，则 await 表达式的类型是 T。如果操作返回 Task，则 await 表达式通常用于仅等待操作完成，而不获取其效果。
  

示例

下面是一个简单的异步方法示例，该方法利用 HttpClient 异步获取网页的内容：

1. using System;
2. using System.Net.Http;
3. using System.Threading.Tasks;
5. class Program
6. {
7.     static async Task Main(string[] args)
8.     {
9.         string content = await GetWebPageAsync("https://www.example.com");
10.         Console.WriteLine(content);
11.     }
13.     static async Task<string> GetWebPageAsync(string url)
14.     {
15.         using (HttpClient client = new HttpClient())
16.         {
17.             HttpResponseMessage response = await client.GetAsync(url);
18.             if (response.IsSuccessStatusCode)
19.             {
20.                 return await response.Content.ReadAsStringAsync();
21.             }
22.             else
23.             {
24.                 throw new HttpRequestException($"Status code does not indicate success: {response.StatusCode}");
25.             }
26.         }
27.     }
28. }

复制代码

在这个示例中，Main 方法被标记为 async，这允许它内部利用 await。GetWebPageAsync 方法是另一个异步方法，它利用 HttpClient 的 GetAsync 方法来异步获取网页，并利用 await 等待操作完成。然后，它读取响应内容并返回。留意，非常处理也是异步编程中的一个重要方面，上述示例展示了如何在异步方法中抛出和捕获非常。

---

高效异步

在.NET Core（或现在更常见的.NET 5/6/7等）中实现高效的异步操作主要依赖于理解异步编程模式，特别是如何准确利用async和await关键字，以及理解异步操作背后的线程和使命的管理。以下是一些实现高效异步操作的关键点：
1. 理解async和await

• 利用async修饰方法：这表现该方法是异步的，并允许在方法内部利用await。
  
• 利用await等待异步操作：这会导致当火线法的执行暂停，并在异步操作完成时恢复。重要的是要等待那些真正需要等待的操作，制止不须要的await调用，因为这会增长延迟。
  

2. 制止阻塞调用

• 在异步方法中，应制止利用.Result或.Wait()来等待另一个异步操作的效果，因为这会导致死锁，并破坏异步方法的优势。
  
• 利用await来等待异步操作完成，并让线程池来管理线程。
  

3. 并行与并发

• 并行处理：利用Task.WhenAll来并行执行多个不相互依赖的异步操作，这可以明显进步性能，特别是当这些操作是I/O密集型时。
  
• 并发控制：在需要时利用SemaphoreSlim或async锁（如Mutex的异步版本）来控制对共享资源的并发访问。
  

4. 异步资源管理

• 利用using语句或async版本的IDisposable接口（如果可用）来确保异步操作中的资源被准确释放。
  
• 留意，在async方法中，using语句仍然有用，但Dispose方法将在等待的异步操作完成后调用。
  

5. 制止不须要的异步

• 如果一个操作本身很快，而且是CPU密集型的，那么将其包装为异步大概不会带来性能上的利益，反而大概因为额外的开销（如使命调理和上下文切换）而低落性能。
  

6. 性能测试与调优

• 利用性能测试工具（如BenchmarkDotNet）来测量和比较不同异步实现的性能。
  
• 根据测试效果举行调优，比如优化数据访问模式、减少不须要的异步调用或改进算法。
  

7. 利用符合的异步API

• 尽量利用.NET Core提供的异步API，如HttpClient、FileStream的异步方法等，这些API已经过优化，可以提供更好的性能。
  
• 如果需要，可以本身实现异步方法，但要确保准确管理线程和使命。
  

8. 监控和日记记录

• 在生产情况中监控异步操作的性能，包罗响应时间、吞吐量等关键指标。
  
• 利用日记记录来跟踪异步操作的执行流程，以便在出现问题时举行调试和故障排查。
  

总之，实现高效的异步操作需要综合思量多个方面，包罗准确利用异步编程模式、制止阻塞调用、优化并行与并发、管理资源、制止不须要的异步以及举行性能测试和调优。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4