独立开发者@董川民

Just So So ...

最全C#线程同步查漏补缺

同步构造

当线程 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

  1. 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);    }}

  1. 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 实现的）。

  1. 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("结束");    }}

  1. 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 一样的混合同步构造，使用用户构造和内核构造混合实现，遇到竞争的情况，会先自旋一下，还无法获取到资源，再使用内核构造阻塞线程，所以有更好的性能。

  1. 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();        }    }}

  1. 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();    }}

  1. 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 一致，使用用户构造和内核构造混合实现，遇到竞争的情况，会先自旋一下，还无法获取到资源，再使用内核构造阻塞线程，所以有更好的性能。

  1. 使用 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} 结束");    }}

  1. 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{...} 把代码块包围起来。

  1. 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");        }    }}

  1. 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>/// 测试 ReaderWriterLockSlim/// </summary>class SynchronizedCache{    private ReaderWriterLockSlim _lock = new();
    private Dictionary<int, string> _cache = new();
    /// <summary>    /// EnterReadLock 获取读锁，可以并发读取。    /// </summary>    /// <param name="key"></param>    /// <returns></returns>    public string Read(int key)    {        try        {            _lock.EnterReadLock();
            return _cache[key];        }        finally        {            _lock.ExitReadLock();        }    }
    /// <summary>    /// EnterWriteLock 获取写锁，互斥写入。    /// </summary>    /// <param name="key"></param>    /// <param name="value"></param>    public void Add(int key, string value)     {        try        {            _lock.EnterWriteLock();            _cache.Add(key,value);        }        finally        {            _lock.ExitWriteLock();        }    }
    /// <summary>    /// 测试 ReaderWriterLockSlim 超市功能    /// </summary>    /// <param name="key"></param>    /// <param name="value"></param>    /// <param name="timeout"></param>    /// <returns></returns>    public bool Add(int key, string value, int timeout)    {

        if (_lock.TryEnterWriteLock(timeout))        {            try            {                _cache.Add(key, value);                 return true;            }            finally            {                _lock.ExitWriteLock();            }        }        else        {            return false;        }    }
    /// <summary>    /// ReaderWriterLockSlim 可以使用 ReaderWriterLockSlim.EnterUpgradeableReadLock() 将并发执行的读锁升级为互斥执行的写锁，从而实现先查再更新的功能。    /// </summary>    /// <param name="key"></param>    /// <param name="value"></param>    /// <returns></returns>    public AddOrUpdateStatus AddOrUpdate(int key, string value)    {        try        {            _lock.EnterUpgradeableReadLock();            if (_cache.TryGetValue(key, out var oldValue))            {                if (oldValue == value)                {                    return AddOrUpdateStatus.Unchanged;                }                else                {                    try                    {                        _lock.EnterWriteLock();                        _cache[key] = value;                        return AddOrUpdateStatus.Updated;                    }                    finally                    {                        _lock.ExitWriteLock();                    }                }            }            else            {                try                {                    _lock.EnterWriteLock();                    _cache.Add(key, value);                    return AddOrUpdateStatus.Added;                }                finally                {                    _lock.ExitWriteLock();                }            }        }        finally        {            _lock.ExitUpgradeableReadLock();        }    }
    public void Delete(int key)    {        try        {            _lock.EnterWriteLock();            _cache.Remove(key);        }        finally        {            _lock.ExitWriteLock();        }    }
    public enum AddOrUpdateStatus    {        Added,        Updated,        Unchanged    };
}

最后

回顾了一下知识，总结了一下，发现自己又学到不少。下次回顾一下 Task 的知识。
源码 https://github.com/yijidao/blog/tree/master/TPL/ThreadDemo/ThreadDemo3

本文作者：鹅群中的鸭霸信息来源：cnblogs.com 鹅群中的鸭霸所属分类：C#

董川民

Life is like a box of chocolates,you never know what you're going to get.
ChongQing Movie Motorcycle Website