.NET线程同步技术解读

C#开发者（面试者）都会遇到lock(Monitor)，Mutex，Semaphore，SemaphoreSlim这四个与锁相关的C#类型，本文期望以最简洁明了的方式阐述四种对象的区别。

1. 什么叫线程安全？

教条式理解

如果代码在多线程环境中运行的结果与 单线程运行结果一样，其他变量值也和预期是一样的，那么线程就是安全的；

线程不安全就是不提供数据访问保护，可能出现多个线程先后修改数据造成的结果是脏数据。

2. 发生场景

1.  线程抢占式执行（宏观上临界区片段代码肯定不是原子操作，执行可能会被打断），操作系统的线程调度是随机的， 这导致多线程环境下的【执行顺序存在不确定性】。

2. 多个线程修改同一变量（微观上操作又不是原子的）， 就可能导致【数据不一致】或者竞争条件。

3. 内存可见性问题： 一个线程对共享变量的修改， 无法被其他线程看到，这是因为每个线程都有自己的工作堆栈，而工作堆栈的内容可能与内存中共享变量的副本， 【C#关键字volatile可用于解决内存可见性问题】。

 

 

 

2.1  线程同步： 宏观代码片段场景 

 两个线程都为集合增加元素，我们错误的理解即使是多线程也总有先后顺序吧，集合的两个位置先后塞进去就完了；实际上集合增加元素这个行为看起来简单，实际并不一定是原子操作。

在添加一个元素的时候，它可能会有两步来完成：

1. 在 Items[Size] 的位置存放此元素；
2. 增大 Size 的值。

• 在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置0，之后设置Size=1；

• 如果是在多线程场景下，有两个线程，线程A先将元素存放在位置0，但是此时CPU调度线程A暂停，线程B得到运行机会；线程B也向此ArrayList添加元素，因为此时Size仍然等于0 （注意哦，我们假设添加元素是经过两个步骤，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值。 那好，我们来看看ArrayList的情况，元素实际上只有一个，存放在位置 0，而Size却等于2，形成了脏数据，这种就定义为对ArrayList的新增元素操作是线程不安全的。

线程安全这个问题不单单存在于集合类，我们始终要记得：
Never ever modify a shared resource by multipie threads unless resource is thread-safe.

• 我们对SqlServer，Mongodb，对HttpContext的访问都会涉及thread-safe, 利用C# mongodb driver操作Mongo打包时常用操作是线程安全的，Only a few of the C# Driver classes are thread safe. Among them: MongoServer, MongoDatabase, MongoCollection and MongoGridFS.

• 对于HttpContext 静态属性的操作是线程安全的： Any public static members of this type （HttpContext） are thread safe， any instance members are not guaranteed to be thread safe. 我们常用的是HttpContext.Current

各语言推出了适用于不同范围的线程同步技术来预防以上脏数据（实现线程安全）。

3. C#线程同步技术

话不多说， 给出大图：

四象限对象的区别：

该线程同步技术

• 　支持线程进入的个数
•    是否跨进程支持 

右半区是 跨进程线程同步的 几个系统内核对象，目前基本上不常用，可以忽略；

本次主要聊一聊左半区 （lock/monitor，  semaphoreslim）CRL对象， 也就是语言级别实现的同步锁对象。

- 上半区 lock（Monitor）（支持单线程进入被保护代码，其他线程则必须等待进入的线程完成 {Critical Section}

- 下半区SemaphoreSlim（中文称为信号量）支持并发多线程进入被保护代码，对象在初始化时会指定 最大信号灯数量，当线程请求访问资源，信号量递减，而当他们释放时，信号量计数又递增。

 ① lock（Monitor）

开发者最常用的lock关键字，使用方式相当简单，对于单进程内线程同步相当有效，

lock实际上是Monitor的语法糖，实际的编译代码如下：

object __lockObj = x;
bool __lockWasTaken = false;
try
{
     System.Threading.Monitor.Enter(__lockObj, ref __lockWasTaken);
     // Your code...
}
finally
{
    if (__lockWasTaken) System.Threading.Monitor.Exit(__lockObj);
}

 一般使用私有静态对象作为lock（Monitor）线程同步的同步对象，那配合lock完成代码锁定的那个对象到底起什么作用呢？

   这里面有个SyncBlockIndex的概念，CLR对象

新建的托管堆在内存表现如下：

 

  每个堆对象： 函数表指针（这也是一个重要知识点，用于在多态中判断对象到底是哪个类型）、同步块索引、对象字段；

  其中同步块索引SyncBlockIndex是lock解决线程同步的关键，SyncBlockIndex是一个地址指针（传送门）；

  　　新创建的对象objLock， 其SyncBlockindex =-1， 不指向任何有效同步块；

  　　调用静态类Monitor.Enter(objLock), CRL会寻找一个空闲SyncBlock并将objLock对象的SyncBlockIndex指向该块， 例如上图中ObjectA，ObjectC的SyncBlockIndex指向了2个SyncBlock；

  　　Exit(objLock)会将objLock对象的SyncBlockIndex重新赋为 -1， 释放出来的SyncBlock可以在将来被其他对象SyncBlockIndex引用。 

②  lock（Monitor） vs SemaphoreSlim

  两者都是进程内线程同步技术，SemaphoreSlim信号量支持多线程进入；

 另外SemaphoreSlim 有异步等待方法，支持在异步代码中线程同步， 能解决在async code中无法使用lock语法糖的问题;

// 实例化单信号量
static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1,1);

// 异步等待进入信号量，如果没有线程被授予对信号量的访问权限，则进入执行保护代码；否则此线程将在此处等待，直到信号量被释放为止
await semaphoreSlim.WaitAsync();
try
{
    await Task.Delay(1000);
}
finally
{
    // 任务准备就绪后，释放信号灯。【准备就绪时始终释放信号量】至关重要，否则我们将获得永远被锁定的信号量
    // 这就是为什么在try ... finally子句中进行发布很重要的原因；程序执行可能会崩溃或采用其他路径，这样可以保证执行
    semaphoreSlim.Release();
}

 4. 原子操作

 不同于以上提供的线程安全技术： 是作用在临界代码段的外侧；

计算机还有一种**利用硬件为多个线程共享的变量提供原子操作** 的技术，C# 是interLocked类， golang  sync/atomic 包。

• 数学运算Add public static int Add (ref int location1, int value);
• 位运算  public static int And (ref int location1, int value);
• CAS比较运算：

  public static UIntPtr CompareExchange (ref UIntPtr location1, UIntPtr value, UIntPtr comparand);

           参数1， 是待比较变量； 参数3是与参数1做比较的值 ，如果相等则替换为参数2；  返回值是参数1原始值

• 自增、自减

• 将变量设置为指定值，并返回原始值  作为原子操作
  public static uint Exchange (ref uint location1, uint value);

• 32位机器读取64位值：   public static long Read (ref long location);                     

           The Read method is unnecessary on 64-bit systems, because 64-bit read operations are already atomic. On 32-bit systems, 64-bit read operations are not atomic unless performed using Read.

 

  着重理解一下 CompareExchange又叫CAS，这是一种乐观锁的思想。

 do
        {
            // Save the current running total in a local variable.
            initialValue = totalValue;

            // Add the new value to the running total.
            computedValue = initialValue + addend;

            // CompareExchange compares totalValue to initialValue. If
            // they are not equal, then another thread has updated the
            // running total since this loop started. CompareExchange
            // does not update totalValue. CompareExchange returns the
            // contents of totalValue, which do not equal initialValue,
            // so the loop executes again.
        }
        while (initialValue != Interlocked.CompareExchange(ref totalValue, 
            computedValue, initialValue));     // 虽然返回值不是bool值， 通过返回值（原始值）与比较值的比较来判断  原始比较。
        // If no other thread updated the running total, then 
        // totalValue and initialValue are equal when CompareExchange
        // compares them, and computedValue is stored in totalValue.
        // CompareExchange returns the value that was in totalValue
        // before the update, which is equal to initialValue, so the 
        // loop ends.

        // The function returns computedValue, not totalValue, because
        // totalValue could be changed by another thread between
        // the time the loop ends and the function returns.
        return computedValue;

原子操作是一种无锁技术， 由硬件保证，由cpu指令完成。

https://learn.microsoft.com/en-us/dotnet/api/system.threading.interlocked.compareexchange?view=net-8.0

总结

从宏观上掌握 Monitor，Mutex， SemaphoreSlim，Semaphore的区别有利于形成【线程同步知识体系】；

文章着重记录 进程内线程同步技术， 同时我们也要理解内核态线程同步的两大法宝 Mutex Semaphore的基本原理。