关于多线程本质的思考

关于多线程本质的思考和使用技巧

前言

​        近来，公司因为项目过多，人手不足，一直在进行面试。过程中同事总是问道：多线程是什么，谈谈你对多线程的理解？以我愚见，这并不是一个可以在面试中快速回答的问题，如果面试的时候向我提问，我觉得我无法有条理的回答这个问题。因此，以总结多线程开发为目标，我写下这篇笔记，用于记录自己对多线程的理解和思考，以备不时之需。
什么是多线程

​        不论初入开发生涯的小白和深耕多年的老兵，提及多线程，第一想到就是加锁，用来确保代码正确执行，避免程序调度的不可预测性导致的错误。但这只是问题的表层，在复杂的并发场景中，锁只是工具，而不是答案。多线程开发远不止“避免冲突”，它是一场在“性能”与“正确性”之间的精细博弈。
多线程开发的目标

​        多线程开发的根本目标：在并发环境下，正确高效的保证对共享资源的访问。

• 正确性:不论线程如何调度，指令如何优化，确保程序的正常运行。
  
• 性能：充分利用多核 CPU，提升吞吐、响应速度。
  

多线程开发问题的本源

我将多线程问题总结为这四类。
问题类型描述指令重排CPU 或编译器为了优化，会调整语句顺序执行，导致逻辑失真缓存不一致不同线程可能看到同一个变量的不同值非原子操作多步骤操作中途被其他线程打断，导致逻辑出错同步代价加锁带来上下文切换和等待，降低性能代码实践

• 指令重排序
  
  指令重排并不会影响单线程的语义，但在多线程环境中，它可能导致“已经构造的对象”被其他线程提前访问，触发 NullReferenceException 或逻辑错误。
  例：双重检查锁下的单例初始化
  1. class Singleton {
  2.     private static volatile Singleton _instance;
  3.     private static object _lock = new object();
  5.     public static Singleton Instance {
  6.         get {
  7.             if (_instance == null) {
  8.                 lock (_lock) {
  9.                     if (_instance == null) {
  10.                         _instance = new Singleton(); // 非原子操作 + 指令重排
  11.                     }
  12.                 }
  13.             }
  14.             return _instance;
  15.         }
  16.     }
  17. }

  复制代码
  volatile 禁止指令重排
  没有 volatile 的场景下，可能出现对象“已分配但未初始化”
  延伸方案
  
  
  
  • 使用 Lazy 避免双检锁与重排问题
    
  • 使用 Thread.MemoryBarrier() 精细控制执行顺序
    
  
  
• 缓存不一致
  

多核 CPU 每个核心拥有自己的缓存，导致线程对同一变量的访问结果可能不一致。
例：线程 A 设置标志位，线程 B 却一直看不到变化

1. volatile bool _shouldStop = false;
3. void Worker() {
4.     while (!_shouldStop) {
5.         // do something
6.     }
7. }
9. void Stop() {
10.     _shouldStop = true;
11. }

复制代码

加上 volatile 保证线程 B 能“看到”线程 A 的写入
或者通过锁封装 _shouldStop，隐式解决可见性

• 非原子操作
  例：多线程计数器累加出错
  1. int counter = 0;
  2. Parallel.For(0, 10000, i => {
  3.     counter++; // 错误！ 非原子操作
  4. });
  5. int counter = 0;
  6. Parallel.For(0, 10000, i => {
  7.    Interlocked.Increment(ref counter); // 正确 原子操作
  8. });

  复制代码
  避免使用 lock 的性能开销
  支持 Increment, Decrement, CompareExchange 等原子操作
  
• 同步代价
  例：任务过多时线程阻塞严重，导致性能瓶颈
  1. SemaphoreSlim semaphore = new SemaphoreSlim(10);
  3. Parallel.ForEach(tasks, async task => {
  4.     await semaphore.WaitAsync();
  5.     try {
  6.         await DoWork(task);
  7.     }
  8.     finally {
  9.         semaphore.Release();
  10.     }
  11. });

  复制代码
  替代思路
  
  
  
  • 限流但不阻塞的任务调度：Channel + 消费者模型
    
  • 利用 Task.Factory.StartNew 创建长时间运行任务，避免线程饥饿
    
  • 用对象池（比如 ConcurrentBag）重用资源，减少锁粒度
    
  
  

延伸多线程的使用方式

以下是我在多线程开发中常用的一些工具，它们不是简单的 API，而是有明确使用语境、性能取舍和设计哲学的并发利器。

• ConcurrentDictionary.GetOrAdd()：
  
  ​        在高并发场景中，我们经常希望“某个对象在多个线程中只初始化一次”，传统做法可能是加锁或双重检查，但 ConcurrentDictionary 通过内部的分段锁和原子操作，实现了线程安全的初始化逻辑：
  1. var instance = dict.GetOrAdd(key, k => new ExpensiveObject());

  复制代码
• lock, Monitor, SpinLock：
  
  lock / Monitor.Enter/Exit
  
  1. lock (_lockObj) {
  2.     // 临界区
  3. }

  复制代码
  
  
  • 最常用的同步方式，基于 Monitor
    
  • 自动释放锁，结构清晰，推荐首选
    
  Monitor.TryEnter：支持超时
  
  1. if (Monitor.TryEnter(_lockObj, TimeSpan.FromSeconds(2))) {
  2.     try { /* ... */ }
  3.     finally { Monitor.Exit(_lockObj); }
  4. }

  复制代码
  SpinLock：避免上下文切换的高性能锁
  
  1. csharp复制编辑SpinLock _spinLock = new SpinLock();
  2. bool lockTaken = false;
  3. _spinLock.Enter(ref lockTaken);
  4. // 临界区
  5. _spinLock.Exit();

  复制代码
  
  
  • 适合锁持有时间极短的场景
    
  • 无线程切换，减少调度开销
    
  • 注意死锁风险 + 不支持递归加锁
    
  
  
• ThreadLocal：
  
  多线程共享变量容易引发冲突，不如不共享。ThreadLocal 允许每个线程持有自己的副本，避免锁：
  1. ThreadLocal<Random> rng = new ThreadLocal<Random>(() => new Random());
  3. int num = rng.Value.Next();

  复制代码
  
  
  • 常用于 Random、日志上下文、缓冲区等隔离场景
    
  • 不适合长生命周期对象（会引起内存泄漏）
    
  
  
• 线程池调度：Task.Run, TaskFactory, Parallel.ForEach
  
  
  
  • Task.Run：将工作提交给线程池，避免频繁创建线程
    
  • TaskFactory.StartNew：高级配置（调度器、长时间运行等）
    
  • Parallel.ForEach：简洁处理并行集合任务（如批处理、文件处理）
    
  1. Parallel.ForEach(myList, item => {
  2.     Process(item);
  3. });

  复制代码
  注意：线程池线程默认不能被控制上下文，如需隔离状态应结合 ThreadLocal 或信号量。
  
  
• [MethodImpl(MethodImplOptions.Synchronized)]：方法级同步声明（不推荐）
  1. [MethodImpl(MethodImplOptions.Synchronized)]
  2. void MyCriticalMethod() {
  3.     // 隐式锁定 this
  4. }

  复制代码
  等价于在方法体前加 lock(this),可能导致外部死锁，不透明、难调试
  
• Lazy：
  
  1. Lazy<HeavyObject> lazyObj = new Lazy<HeavyObject>(() => new HeavyObject());
  3. var obj = lazyObj.Value; // 初始化只发生一次

  复制代码
  
  
  • 内部实现使用双检锁+volatile，线程安全
    
  • 默认线程安全（LazyThreadSafetyMode.ExecutionAndPublication）
    
  
  
• System.Threading.Channels：
  
  1. var channel = Channel.CreateUnbounded<string>();
  3. // Producer
  4. await channel.Writer.WriteAsync("msg");
  6. // Consumer
  7. await foreach (var msg in channel.Reader.ReadAllAsync()) {
  8.     Process(msg);
  9. }

  复制代码
  
  
  • 内部使用环形缓冲 + 原子操作，无需锁
    
  • 广泛用于 高性能日志、异步消息、管道通信
    
  
  
• CancellationToken：
  
  1. var cts = new CancellationTokenSource();
  2. var token = cts.Token;
  4. var task = Task.Run(() => {
  5.     while (!token.IsCancellationRequested) {
  6.         // work
  7.     }
  8. }, token);
  10. cts.Cancel(); // 触发取消

  复制代码
  
  
  • 支持协作式停止线程
    
  • 适用于定时任务、消费者线程、异步服务
    
  
  
• BlockingCollection：线程安全的队列 + 阻塞消费
  
  1. var queue = new BlockingCollection<string>();
  3. // Producer
  4. Task.Run(() => {
  5.     for (int i = 0; i < 100; i++) {
  6.         queue.Add($"msg-{i}");
  7.     }
  8.     queue.CompleteAdding();
  9. });
  11. // Consumer
  12. foreach (var msg in queue.GetConsumingEnumerable()) {
  13.     Console.WriteLine(msg);
  14. }

  复制代码
  
  
  • 自动处理线程同步
    
  • 自动等待生产或消费，无需手动 wait 或 signal
    
  • 适合简化 Producer-Consumer 模型
    
  
  
• 使用 ValueTask 减少分配（高频异步方法）
  
  1. public ValueTask<int> ReadAsync() {
  2.     if (_cachedResult != null) {
  3.         return new ValueTask<int>(_cachedResult);
  4.     }
  5.     return new ValueTask<int>(ReadFromDiskAsync());
  6. }

  复制代码
  
  
  • 避免频繁创建 Task 对象
    
  • 适合“同步返回的概率高”的场景，如缓存读取
    
  
  

来源：新程序网络收集，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！