C# 线程同步查漏补缺

技术分享 2年前 (2023-02-03) 0 999+

关注

同步构造

当线程 A 在等待一个同步构造，另一个线程 B 持有构造一直不释放，那么就会导致线程 A 阻塞。同步构造有用户模式构造和内核模式构造。

用户模式构造通过 CPU 指令来协调线程，所以速度很快。也意味着不受操作系统控制，所以等待构造的线程会不停自旋，浪费 CPU 时间。
内核模式构造通过操作系统来协调线程。内核构造在获取时，需要先转换成本机代码，在转换成内核代码，返回时则需要反方向再转换一次，所以速度会比用户构造慢很多。
因为使用了操作系统来协调线程，所以也有了更加强大的功能。
1. 不同线程在竞争一个资源时，操作系统会阻塞线程，所以不会自旋。
2. 可以实现托管线程和本机线程的同步。
3. 可以跨进程跨 domain 同步。
4. 可以利用 WaitHandle 类的方法实现多个构造的同步或者超时机制。

活锁和死锁：
当线程获取不到资源，从而不停在 CPU 上自旋等待资源，就会形成活锁。这是通过用户构造实现的。
当线程获取不到资源，被操作系统阻塞，就会形成死锁。这是通过内核构造实现的。

用户模式构造

.Net 提供了两种用户构造，易变构造 Volatile、互锁构造 Interlocked，这两种构造都提供了原子性读写的功能。
.Net 提供了基于易变构造、互锁构造、SpinWait 实现的自旋锁 SpinLock。

原子性读写：
在 32 位 CPU 中，CPU 一次只能存储 32 位的数据，所以如果是 64 位的数据类型（如 double），就得执行两次 MOV 指令，所以在 32 位 CPU 和 32 位操作系统中，不同线程对 64 位的数据类型进行读写可能得到不同的结果。原子性读写就是保证了即使是 64 位的数据类型，不同线程读写也会得到相同的结果。现在的 CPU 和操作系统基本都是 64 位的，所以一般也不会遇到这种问题。

易变构造 Volatile 和 volatile 关键字

Volatile 一般用于阻止编译器代码优化，编译器优化代码会优化掉一些在单线程情况下无用的变量或者语句，在多线程代码下有时候会导致程序运行结果跟设计的不一样。
Volatile.Read() 强制对变量的取值必须在调用时读取，Volatile.Write() 强制对变量的赋值必须在调用时写入。

/// <summary> /// 在 debug 模式下不开启代码优化，所以需要用 release 模式下生成。 /// 执行 dotnet build -c release --no-incremental 后运行代码，如果没有标记为易变，则不会打印 x。 /// </summary> public void Test2() {     var switchTrue = false;      var t = new Thread(() =>     {         var x = 0;         while (!switchTrue) // 如果没有标记变量为易变，编译器会把 while(!switchTrue) 优化为 while(true) 从而导致永远不会打印出 x 的值         //while (!Volatile.Read(ref switchTrue)) // 标记为易变，可以保证在调用时才进行取值，不会进行代码优化。         {             x++;         }         Console.WriteLine($"x: {x}");     });     t.IsBackground = true;     t.Start();      Thread.Sleep(100);     switchTrue = true;     Console.WriteLine("ok"); }

互锁构造 Interlocked

Interlocked 除了保证原子性读写外，还提供了很多方便的方法，在调用的地方建立了内存屏障，所以可以用来实现各种锁。

/// <summary> /// 用 Interlocked 实现一个简单的自旋锁 /// 注意： /// 1. 自旋锁在获取不到锁的时候，会进行空转。所以在自旋的时候，会占用 CPU，所以一般不在单 CPU 机器上用。 /// 2. 当占有锁的线程优先级比获取锁的线程更低的时候，会导致占有锁的线程一直获取不到CPU进行工作，从而无法释放锁，导致活锁。 ///    所以使用自旋锁的线程，应该禁用线程优先级提升功能。 /// </summary> public class SimpleSpinLock {     private int _count;     public void Enter()     {         while (true)         {             if (Interlocked.Exchange(ref _count, 1) == 0)             {                 return;             }         }     }      public void Exit()     {         Volatile.Write(ref _count, 0);     } }

Interlocked 也经常用来实现单例模式。实现单例模式经常用 lock 关键字和双检索模式的，但我都是用 Interlocked 或者 Lazy，因为更轻量代码也简单。

/// <summary> /// 使用 Interlocked 实现的单例，轻量且简单。 /// 可能会同时调用多次构造函数，所以适合构造函数没有副作用的类 /// </summary> internal class DoubleCheckLocking3 {     private static DoubleCheckLocking3? _value;      private DoubleCheckLocking3()     {      }      private DoubleCheckLocking3 GetInstance()     {         if (_value != null) return _value;         Interlocked.CompareExchange(ref _value, new DoubleCheckLocking3(), null);         return _value;     } }  /// <summary> /// 使用 lock 和双检索实现的单例化 /// </summary> internal class DoubleCheckLocking {     private static DoubleCheckLocking? _value;      private static readonly object _lock = new();      private DoubleCheckLocking()     {      }      public static DoubleCheckLocking GetInstance()     {         if (_value != null) return _value;         lock (_lock)         {             if (_value == null)             {                 var t = new DoubleCheckLocking();                 Volatile.Write(ref _value, t);              }         }         return _value;     } }

自旋锁 SpinLock

.Net 提供了一个轻量化的同步构造 SpinLock，很适合在不常发生竞争的场景使用。如果发生竞争了，会先在 CPU 上自旋一段时间，如果还不能获取到资源，就会让出 CPU 控制权给其他线程（使用 SpinWait 实现的）。

SpinLock 不支持重入锁，当给构造函数 SpinLock(bool) 传入 true 时，重入锁会抛出异常，否则就会死锁。

重入锁（Re-Enter）: 就是一个线程调用了 SpinLock.Enter() 后，没有调用 SpinLock.Exit()，再次调用了 SpinLock.Enter()。

/// <summary> /// 测试 SpinLock 重入锁 /// </summary> public void Test3() {     var spinLock = new SpinLock(true); // 如果传 true，如果 SpinLock 重入锁，就会抛出异常，传 false 则不会，只会死锁。      ThreadPool.QueueUserWorkItem(_ => DoWork());      void DoWork()     {         var lockTaken = false;          for (int i = 0; i < 10; i++)         {             try             {                 Thread.Sleep(100);                 if (!spinLock.IsHeldByCurrentThread)  // SpinLock.IsHeldByCurrentThread 可以判断是不是当前线程拥有锁，如果是就不再获取锁                 {                     Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 获取锁，i 为 {i}");                     spinLock.Enter(ref lockTaken);                 }                 //spinLock.Enter(ref lockTaken); // 重入锁会死锁              }             catch (Exception e)             {                 Console.WriteLine(e);             }         }          if (lockTaken) // 使用 lockTaken 来判断锁是否已经被持有         {             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 释放锁");             spinLock.Exit();         }         Console.WriteLine("结束");     } }

SpinLock 是 Struct 类型的，所以注意装箱拆箱。

/// <summary> /// 测试装箱拆箱问题 /// </summary> public void Test4() {     var spinLock = new SpinLock(false);     Task.Run(() => DoWork(ref spinLock));     Task.Run(() => DoWork(ref spinLock));      // SpinLock 是 Struct 类型，要注意装箱拆箱的问题，试试看不加 ref 关键字的效果     void DoWork(ref SpinLock spinLock)     {         var lockTaken = false;         Thread.Sleep(500);         spinLock.Enter(ref lockTaken);         Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 获取锁");     } }

内核模式构造

WaitHandle

.Net 提供了 System.Threading.WaitHandle 和 WaitHandle 的子类来支持内核构造，WaitHandle 封装内核同步构造的句柄，并且提供了操作的方法，并且每个方法都会在调用处建立内存屏障。

WaitHandle 有以下实现类，这些类定义了一个信号机制，根据信号去释放线程或者阻塞线程，用于在多线程的场景下访问共享资源：
WaitHandle：抽象基类，封装了系统内核构造的句柄。继承自 MarshalByRefObject，所以可以跨进程和 domain 边界。

EventWaitHandle：事件构造。由内核维护了一个 bool 变量，为 false 阻塞线程，为 true 时释放线程。
- AutoResetEvent：自动重置事件构造。调用 AutoResetEvent.Set() 每次只释放一个阻塞线程。
- ManualResetEvent：手动重置事件构造。调用 ManualResetEvent.Set() 会释放所有阻塞线程，并且不会有阻塞线程的功能，需要调用 ManualResetEvent.ReSet() 才能再次阻塞线程。
Semaphore：信号量。由内核维护了一个 Int32 变量，为当值为 0 时，阻塞线程，调用 Semaphore.Release() 会把变量加 1，调用 WaitHandle.WaitOne() 会把变量减 1。
Mutex：互斥体。功能跟 Semaphore(1) 和 AutoResetEvent 类似，一次只能释放一个线程。

WaitHandle 有以下常用方法：

WaitHandle.WaitOne() 虚方法，等待一个同步构造。
WaitHandle.WaitAll() 等待一组同步构造全部解除阻塞。
WaitHandle.WaitAny() 等待一组同步构造中的一个解除阻塞。
WaitHandle.SignalAndWait(WaitHandle x, WaitHandle y) 传入两个同步构造，解除第一个构造的阻塞，等待第二个构造。

public class WaitHandleDemo {     /// <summary>     /// 测试 WaitHandle.WaitAll()， 成功运行返回 true, 支持超时，当超时时，返回 false     ///  WaitHandle.WaitAny()， 成功运行返回对应的 索引，支持超时，当超时时，返回 WaitHandle.WaitTimeout     /// </summary>     public void Test()     {         var waitHandleList = new WaitHandle[] { new AutoResetEvent(false), new AutoResetEvent(false) };          ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[0]);         ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[1]);         var timeout = WaitHandle.WaitAll(waitHandleList);         Console.WriteLine($"是否超时：{!timeout}，WaitHandle.WaitAll() 结束");          Thread.Sleep(500);          ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[0]);         ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[1]);         timeout = WaitHandle.WaitAll(waitHandleList,1000);         Console.WriteLine($"是否超时：{!timeout}，WaitHandle.WaitAll() 结束");          ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[0]);         ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[1]);         var index = WaitHandle.WaitAny(waitHandleList);         Console.WriteLine($"{index} 已经结束运行，WaitHandle.WaitAny() 结束");          ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[0]);         ThreadPool.QueueUserWorkItem(DoWork, waitHandleList[1]);         index = WaitHandle.WaitAny(waitHandleList, 1000);         Console.WriteLine($"是否超时：{WaitHandle.WaitTimeout == index}，WaitHandle.WaitAny() 结束");                   void DoWork(object? state)         {             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 开始");              var r = new Random();             var interval = 1000 * r.Next(2, 10);             Thread.Sleep(interval);             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 结束");              ((AutoResetEvent)state).Set();         }     }      /// <summary>     /// 测试 WaitHandle.SignalAndWait()， 成功运行返回 true, 支持超时，当超时时，返回 false     /// </summary>     public void Test2()     {         var are = new AutoResetEvent(false);         var are2 = new AutoResetEvent(false);          foreach (var i in Enumerable.Range(1,5))         {             Console.WriteLine($"按下 Enter 启动线程 {i}");             Console.ReadLine();             var t = new Thread(DoWork)             {                 Name = $"线程 {i}"             };             t.Start();             WaitHandle.SignalAndWait(are, are2); // 给 are 发信号，同时等待 are2         }          Console.WriteLine("全部线程运行结束");          void DoWork()         {             are.WaitOne();             Console.WriteLine($"{Thread.CurrentThread.Name} 开始");             Thread.Sleep(1000);             Console.WriteLine($"{Thread.CurrentThread.Name} 结束");             are2.Set();         }     } }

EventWaitHandle、ManualResetEvent、AutoResetEvent、ManualResetEventSlim

EventWaitHandle、ManualResetEvent、AutoResetEvent 是内核同步构造，EventWaitHandle 由内核维护了一个 bool 变量，为 false 的时候阻塞线程，为 true 的时候释放线程。ManualResetEvent、AutoResetEvent 继承自 EventWaitHandle，所以拥有一样的行为，同时可以跨进程跨 domain 通信。
ManualResetEventSlim 并不继承自 EventWaitHandle，只是功能跟 ManualResetEvent、AutoResetEvent 一样的混合同步构造，使用用户构造和内核构造混合实现，遇到竞争的情况，会先自旋一下，还无法获取到资源，再使用内核构造阻塞线程，所以有更好的性能。

EventWaitHandle 一般在构造函数中传入 name，用来跨进程或者跨 domain 通信。

/// <summary> /// 测试 EventWaitHandle 跟其他线程通信 /// </summary> public void Test2() {     EventWaitHandle ewh;     if (EventWaitHandle.TryOpenExisting("multi-process", out ewh))     {         Console.WriteLine("等待 EventWaitHandle");         ewh.WaitOne();         Console.WriteLine("结束运行");     }     else     {         ewh = new EventWaitHandle(false, EventResetMode.AutoReset, "multi-process");         while (true)         {             Console.WriteLine("按下 Enter 跟其他线程通讯");             Console.ReadLine();             ewh.Set();         }     } }

ManualResetEvent 调用完 ManualResetEvent.Set() 后会释放所有阻塞线程，如果需要再次阻塞线程，需要调用 ManualResetEvent.Reset()。

/// <summary> /// 测试 ManualResetEvent.Set() 和 ManualResetEvent.Reset() /// </summary> public void Test1() {     var mre = new ManualResetEvent(false);      foreach (var i in Enumerable.Range(1, 3))     {         StartThread(i);     }     Thread.Sleep(500);     Console.WriteLine("按下 Enter 调用 Set()，释放所有线程");     Console.ReadLine();     mre.Set();     Thread.Sleep(500);      Console.WriteLine("ManualResetEvent 内部值为 true 时，不会阻塞线程。按下 Enter 启动一个新线程进行测试");     Console.ReadLine();      StartThread(4);     Thread.Sleep(500);      Console.WriteLine("按下 Enter 调用 Reset()，可以再次阻塞线程");     Console.ReadLine();     mre.Reset();     Thread.Sleep(500);       foreach (var i in Enumerable.Range(5, 2))     {         StartThread(i);     }     Thread.Sleep(500);      Console.WriteLine("按下 Enter 调用 Set()，释放所有线程，结束 demo");     Console.ReadLine();     mre.Set();     Thread.Sleep(500);      void StartThread(int i)     {         var t = new Thread(() =>         {             Console.WriteLine($"{Thread.CurrentThread.Name} 启动并调用 WaitOne()");             mre.WaitOne();             Console.WriteLine($"{Thread.CurrentThread.Name} 结束运行");         })         {             Name = $"线程_{i}"         };         t.Start();     } }

AutoResetEvent 每次调用 AutoResetEvent.Set() 都只会释放一个阻塞的线程。

public void Test() {     var are = new AutoResetEvent(false);      Task.Run(() =>     {         for (int i = 0; i < 5; i++)         {             Thread.Sleep(500);             Console.WriteLine("按下 Enter 释放一个线程");             Console.ReadLine();             are.Set();         }     });      foreach (var i in Enumerable.Range(1,5))     {         var t = new Thread(DoWork);         t.Name = $"线程 {i}";         t.Start();     }      void DoWork()     {         Console.WriteLine($"{Thread.CurrentThread.Name} 开始");         are.WaitOne();         Console.WriteLine($"{Thread.CurrentThread.Name} 结束");     } }

Semaphore、SemaphoreSlim

Semaphore 是一个内核构造，由内核维护了一个 Int32 变量，为当值为 0 时，阻塞线程，调用 Semaphore.Release() 会把变量加 1，调用 WaitHandle.WaitOne() 会把变量减 1。
SemaphoreSlim 是一个混合构造，功能跟 Semaphore 一致，使用用户构造和内核构造混合实现，遇到竞争的情况，会先自旋一下，还无法获取到资源，再使用内核构造阻塞线程，所以有更好的性能。

使用 Semaphore 释放多个线程。

/// <summary> /// 测试 Semaphore /// </summary> public void Test4() {     var pool = new Semaphore(1, 3); // 初始化计数 1，最大计数 3      foreach (var i in Enumerable.Range(1, 5))     {         var t = new Thread(DoWork);         t.Name = $"线程 {i}";         t.Start();     }      Thread.Sleep(500);     Console.WriteLine("按下 Enter 释放 3 个线程");     Console.ReadLine();     pool.Release(3); // 计数加3     Thread.Sleep(500);     Console.WriteLine("再按下 Enter 释放 1 个线程");     Console.ReadLine();     pool.Release(); // 计数加1      void DoWork()     {         Console.WriteLine($"{Thread.CurrentThread.Name} 开始");         pool.WaitOne(); // 计数减1         Console.WriteLine($"{Thread.CurrentThread.Name} 结束");     } }

Semaphore 继承自 WaitHandle，所以在构造函数中传入 name 可以跨进程跨 domain 同步。把 Semaphore 的最大计数设置为 1，可以实现跟 AutoResetEvent 一样每次只解除一个阻塞线程的行为。

/// <summary> /// 测试跟其他进程通讯 /// </summary> public void Test5() {     Semaphore pool;     if (Semaphore.TryOpenExisting("multi-process", out pool))     {         Console.WriteLine("等待 Semaphore");         pool.WaitOne();         Console.WriteLine("结束");     }     else     {         pool = new Semaphore(0, 1, "multi-process"); // 最大计数设置为 1，每次只解除一个阻塞。          while (true)         {             Console.WriteLine("按下 Enter 跟其他线程通讯");             Console.ReadLine();             pool.Release();         }     } }

Mutex

Mutex 是一个内核构造，经常用于进程同步（如保证只有程序只能有一个进程）。功能跟 AutoResetEvent(false) 和 Semaphore(0,1) 类似，每次只能阻塞一个线程或者进程。
Mutex 跟 EventWaitHandle 和 Semaphore 不一样的地方是，Mutex 要求线程一致（也就是获取和释放都必须在同一个线程），并且支持重入锁。

/// <summary> /// Mutex 支持重入锁，支持线程一致 /// </summary> public void Test() {     var mutex = new Mutex(false);     var count = 0;     DoWork(mutex);      void DoWork(Mutex mutex)     {         try         {             mutex.WaitOne();             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 获取 Mutex");             Interlocked.Increment(ref count);             Thread.Sleep(1000);             if (Interlocked.CompareExchange(ref count, 3, 3) == 3)             {                 return;             }             DoWork(mutex);         }         finally         {             mutex.ReleaseMutex(); // 调用几次 WaitOne() 就必须调用几次 ReleaseMutex()，并且调用 WaitOne() 和 ReleaseMutex() 必须在同一个线程。             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 释放 Mutex");         }     } }

用户模式构造、内核模式构造性能对比

从上面可以看出，.Net 内核构造功能比用户构造强大得多，所以看起来似乎直接使用内核构造，而不使用用户模式构造更加明智。
但是用户构造会比内核构造快，所以在不常发生竞争或者性能敏感的场景下，使用用户构造会是一个更加优秀的做法。接下来用一个没有竞争的空方法测试一下快多少。

internal class PerformanceDemo {     /// <summary>     /// 测试用户模式构造和内核模式构造，在锁没有发生竞争的情况下的性能差距     /// </summary>     public void Test()     {         var count = 1000 * 10000;         var spinLock = new SpinLock(false);         var are = new AutoResetEvent(true);         var pool = new Semaphore(1, 1);          var sw = Stopwatch.StartNew();         foreach (var _ in Enumerable.Range(0, count))         {             var lockTaken = false;             spinLock.Enter(ref lockTaken);             DoWork();             spinLock.Exit(lockTaken);         }         Console.WriteLine($"在没有竞争的场景下，执行一个空方法一千万次，SpinLock 耗时：{sw.ElapsedMilliseconds} ms");          sw.Restart();         foreach (var _ in Enumerable.Range(0, count))         {             are.WaitOne();             DoWork();             are.Set();         }         Console.WriteLine($"在没有竞争的场景下，执行一个空方法一千万次，AutoResetEvent 耗时：{sw.ElapsedMilliseconds} ms");          sw.Restart();         foreach (var _ in Enumerable.Range(0, count))         {             pool.WaitOne();             DoWork();             pool.Release();         }         Console.WriteLine($"在没有竞争的场景下，执行一个空方法一千万次，Semaphore 耗时：{sw.ElapsedMilliseconds} ms");          // 空方法         void DoWork()         {          }     } } // 输出： // 在没有竞争的场景下，执行一个空方法一千万次，SpinLock 耗时：184 ms // 在没有竞争的场景下，执行一个空方法一千万次，AutoResetEvent 耗时：5449 ms // 在没有竞争的场景下，执行一个空方法一千万次，Semaphore 耗时：5366 ms

最终在我的机子上测试，在没有发生竞争的场景下，.NET 提供的用户构造性能是内核构造的 30 倍，所以性能差距还是非常大的。

混合构造

用户构造在遇到竞争，在长时间获取不到资源的场景，会一直在 CPU 上自旋，既浪费 CPU 时间，又耽误其他线程执行，内核构造在操作系统的协调下，会把获取不到资源的线程阻塞，不会浪费 CPU 时间。
内核构造在没有竞争的场景下，性能会比用户构造差几十倍。
混合构造就是组合用户构造和内核构造的实现，遇到竞争的时候，先使用用户构造自旋一下，自旋一段时间还没获取到资源，就使用内核构造阻塞线程，这样就能结合两种构造的优点了。
.Net 提供了 ManualResetEventSlim、SemaphoreSlim、Monitor、lock 关键字、ReaderWriterLockSlim、CountDownEvent、Barrier 等混合构造，可以在不同的场景下使用。

自定义一个简单的混合构造

通过这个例子可以了解一下是怎么组合内核构造和用户构造的。

/// <summary> /// 一个简单的混合构造，组合 AutoResetEvent 和 Interlocked 实现 /// </summary> internal class SimpleHybridLock : IDisposable {     private int _waiter;     private AutoResetEvent _waiterLock = new(false);       public void Enter()     {         if (Interlocked.Increment(ref _waiter) == 1)         {             return;         }          _waiterLock.WaitOne();     }      public void Exit()     {         if (Interlocked.Decrement(ref _waiter) == 0)         {             return;         }          _waiterLock.Set();     }      public void Dispose()     {         _waiterLock.Dispose();     } }

Monitor 和 lock 关键字

lock 关键字是最常使用的同步构造了，lock 可以锁定一个代码块，保证每次只有一个线程访问执行该代码块，lock 是基于 Montor 实现的，通过 try{...}finally{...} 把代码块包围起来。

Monitor 是一个静态类，调用 Monitor.Enter(obj) 获取锁，调用 Monitor.Exit(obj) 释放。还可以在已经获取锁的线程上，调用 Monitor.Wait(obj) 释放锁，同时把线程放到等待队列，其他线程可以调用 Monitor.Pulse() 或 Monitor.PulseAll() 通知调用了 Monitor.Wait() 的线程继续获得锁。
Monitor 支持重入锁，线程一致。

/// <summary> /// 测试 Monitor.Wait(object)、Monitor.Pulse(object)、Monitor.PulseAll(object) /// 注意点： /// 调用 Wait()、Pulse()、PulseAll() 也必须先调用 Enter() 获取锁，退出的时候也必须调用 Exit() 释放锁 /// </summary> public void Test() {     var lockObj = new object();      Task.Factory.StartNew(() =>     {         Thread.Sleep(500);         Console.WriteLine("按下 c 调用 Monitor.Pulse(object)");          if (Console.ReadKey().Key == ConsoleKey.C)         {             try             {                 Monitor.Enter(lockObj);                 Monitor.Pulse(lockObj);             }             finally             {                 Monitor.Exit(lockObj);             }         }         Thread.Sleep(500);          if (Console.ReadKey().Key == ConsoleKey.C)         {             try             {                 Monitor.Enter(lockObj);                 Monitor.PulseAll(lockObj);             }             finally             {                 Monitor.Exit(lockObj);             }         }     });      Parallel.Invoke(DoWork, DoWork, DoWork);      void DoWork()     {         Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 启动");         try         {             Monitor.Enter(lockObj);             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 获得 Monitor");             Thread.Sleep(100);             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 调用 Monitor.Wait()");             Monitor.Wait(lockObj);             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 重新获得 Monitor");          }         finally         {             Monitor.Exit(lockObj);             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 释放 Monitor");         }     } }

Monitor.Enter(object) 参数是一个 object 类型，代表可以传入任何类型的参数，所以就有一些细节需要注意。

Monitor.Enter(值类型)，涉及到值类型传参，就必须注意装箱拆箱的问题。
Monitor.Enter(字符串)，虽然字符串是引用类型，但是字符串会留用，所以锁定同一个字符串就会导致互斥。
如果一个实例对象的方法使用了 lock(this)，如果外部调用也 lock 这个实例方法，那么就会死锁，所以最佳做法是永远不要 lock(this)。

/// <summary> /// 测试 Monitor.Enter(字符串) /// 因为字符串会被留用，所以会导致不同线程间互斥访问。 /// </summary> public void Test2() {     var mre = new ManualResetEventSlim(false);      Task.Run(() =>     {         Console.WriteLine("按下 c 启动");         if (Console.ReadKey().Key == ConsoleKey.C)         {             mre.Set();         }     });      Parallel.Invoke(DoWork, DoWork, DoWork);       void DoWork()     {         mre.Wait();          try         {             Monitor.Enter("1");             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 进入同步代码块");             Thread.Sleep(1000);          }         finally         {             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 退出同步代码块");             Monitor.Exit("1");         }      } }  /// <summary> /// 测试 Monitor.Enter(值类型) /// 因为 Monitor.Enter(object) 参数是 object，所以值类型必须装箱，那样其实就会有问题了。 /// 值类型在堆栈上，没有引用，引用类型在堆上，有引用，所以装箱就是在堆上新建一个实例，然后复制栈上值的内容，拆箱就是把堆上实例的值，复制到栈上。 /// </summary> public void Test3() {     var mre = new ManualResetEventSlim(false);     var i = 1;     //Object o = i;      Task.Run(() =>     {         Console.WriteLine("按下 c 启动");         if (Console.ReadKey().Key == ConsoleKey.C)         {             mre.Set();         }     });      Parallel.Invoke(DoWork, DoWork, DoWork);      void DoWork()     {         mre.Wait();         object o = i;         try         {             Monitor.Enter(o);             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 进入同步代码块");             Thread.Sleep(1000);         }         finally         {             Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} 退出同步代码块");             Monitor.Exit(o);         }      } }

CountdownEvent

CountdownEvent 是一个混合构造，经常用于 fork/join 等场景，就是等待多个并行任务完成，再执行下一个任务。CountdownEvent 内部会维护一个计数，当计数为 0 时，解除线程的阻塞。

调用 CountdownEvent.Reset(int) 可以重新初始化 CountdownEvent。
调用 Signal() Signal(int count) 把计数减 1 或减 count。
调用 AddCount() AddCount(int) 把计数加 1 或加 count。

 public void Test2() {     var queue = new ConcurrentQueue<int>(Enumerable.Range(1, 100));     var cde = new CountdownEvent(queue.Count);      var doWork = new Action(() =>     {         while (queue.TryDequeue(out var result))         {             Thread.Sleep(100);             Console.WriteLine(result);             cde.Signal();         }     });      var _ = Task.Run(doWork); // fork     var _2 = Task.Run(doWork); // fork       var complete = new Action(() =>     {         cde.Wait(); // join         Console.WriteLine($"queue Count {queue.Count}");     });      var t = Task.Run(complete);     var t2 = Task.Run(complete);      Task.WaitAll(t, t2);       Console.WriteLine($"CountdownEvent 重新初始化");     cde.Reset(2); // 调用 Reset() 将 cde 重新初始化     cde.AddCount(10); // 调用 AddCount() cde 内部计数 + 1     var cts = new CancellationTokenSource(1000); // 测试超时机制      try     {         cde.Wait(cts.Token);     }     catch (Exception e)     {         Console.WriteLine(e);     }      cde.Dispose();  }

Barrier

Barrier 是一个混合构造，可以通过 participantCount 来指定一个数值，同时会维护一个内部数值 total，每次调用 SignalAndWait() 的时候，阻塞调用线程，同时把total 加 1，等到 total == participantCount，调用 postPhaseAction，通过 postPhaseAction 来确定汇总每个线程的数据，并且执行下个阶段的工作。
Barrier 适合一种特殊场景，把一个大任务拆分成多个小任务，然后每个小任务又会分阶段执行。像是 Parallel 的 Plus 版，如果任务步骤很多，用 Parallel 来分拆很麻烦，可以考虑用 Barrier。

public class BarrierDemo {     public void Test()     {         var words = new string[] { "山", "飞", "千", "鸟", "绝" };         var words2 = new string[] { "人", "灭", "径", "万", "踪" };         var solution = "千山鸟飞绝，万径人踪灭";         bool success = false;          var barrier = new Barrier(2, b =>         {             var sb = new StringBuilder();             sb.Append(string.Concat(words));             sb.Append('，');             sb.Append(string.Concat(words2));                          Console.WriteLine(sb.ToString());             //Thread.Sleep(1000);             if (string.CompareOrdinal(solution, sb.ToString()) == 0)             {                 success = true;                 Console.WriteLine($"已完成");             }             Console.WriteLine($"当前阶段数：{b.CurrentPhaseNumber}");          });          var t = Task.Run(() => DoWork(words));         var t2 = Task.Run(() => DoWork(words2));          Console.ReadLine();          void DoWork(string[] words)         {             while (!success)             {                 var r = new Random();                 for (int i = 0; i < words.Length; i++)                 {                     var swapIndex = r.Next(i, words.Length);                     (words[swapIndex], words[i]) = (words[i], words[swapIndex]);                 }                  barrier.SignalAndWait();             }         }     } }

ReaderWriterLockSlim

ReaderWriterLockSlim 是一个混合构造。一般场景中在读取数据的时候，不会涉及到数据的修改，所以可以并发读取，在修改数据的时候，才会涉及到数据的修改，所以应该互斥修改。其他同步构造无论读取还是修改数据都是锁定的，所以 .Net 提供了一个读写锁 ReaderWriterLockSlim。
ReaderWriterLockSlim 的逻辑如下：

一个线程向数据写入时，请求访问的其他所有线程都阻塞。
一个线程向数据读取时，请求读取的其他线程允许继续执行，但是请求写入的线程仍被阻塞。
一个向数据写入的线程结束后，要么解除一个写入线程(writer)的阻塞，使它能向数据写入，要么解除所有读取线程(reader)的阻塞，使它们能够进行并发读取。如果没有线程被阻塞，则锁进入自由状态，可以被下一个 reader 或者 writer 线程获取。
所有向数据读取的线程结束后，一个 writer 线程被解除阻塞，使它能向数据写入。如果没有线程被阻塞，则锁进入自由状态，可以被下一个reader 或者 writer 线程获取。

/// <summary> /// ReaderWriterLockerSlim 用法 /// </summary> internal class Transaction2 {     private DateTime _timeLastTrans;      public DateTime TimeLastTrans     {         get         {             _lock.EnterReadLock();             Thread.Sleep(1000);             var t = _timeLastTrans;             Console.WriteLine($"调用 ReadLock {Thread.CurrentThread.ManagedThreadId}");              _lock.ExitReadLock();             return t;         }     }      private readonly ReaderWriterLockSlim _lock = new(LockRecursionPolicy.NoRecursion);      public void PerformTransaction()     {         _lock.EnterWriteLock();         _timeLastTrans = DateTime.Now;         Console.WriteLine($"调用 WriteLock {Thread.CurrentThread.ManagedThreadId}");         _lock.ExitWriteLock();     }      public void Test()     {         PerformTransaction();          ThreadPool.QueueUserWorkItem(_ => Console.WriteLine(TimeLastTrans));          PerformTransaction();         Thread.Sleep(500); // 就算睡眠500ms，在锁释放后，依旧先进行读操作，读完才有写操作。         ThreadPool.QueueUserWorkItem(_ => Console.WriteLine(TimeLastTrans));      } }