线程同步之详解自旋锁

时间 2019-11-12

标签线程同步详解繁體版

原文原文链接

一什么是自旋锁

自旋锁(Spinlock)是一种普遍运用的底层同步机制。自旋锁是一个互斥设备，它只有两个值：“锁定”和“解锁”。它一般实现为某个整数值中的某个位。但愿得到某个特定锁得代码测试相关的位。若是锁可用，则“锁定”被设置，而代码继续进入临界区；相反，若是锁被其余人得到，则代码进入忙循环（而不是休眠，这也是自旋锁和通常锁的区别）并重复检查这个锁，直到该锁可用为止，这就是自旋的过程。“测试并设置位”的操做必须是原子的，这样，即便多个线程在给定时间自旋，也只有一个线程可得到该锁。php

自旋锁对于SMP和单处理器可抢占内核都适用。能够想象，当一个处理器处于自旋状态时，它作不了任何有用的工做，所以自旋锁对于单处理器不可抢占内核没有意义，实际上，非抢占式的单处理器系统上自旋锁被实现为空操做，不作任何事情。html

曾经有个经典的例子来比喻自旋锁：A，B两我的合租一套房子，共用一个厕所，那么这个厕所就是共享资源，且在任一时刻最多只能有一我的在使用。当厕所闲置时，谁来了均可以使用，当A使用时，就会关上厕所门，而B也要使用，可是急啊，就得在门外焦急地等待，急得团团转，是为“自旋”，这也是要求锁的持有时间尽可能短的缘由！linux

自旋锁有如下特色：
___________________算法

用于临界区互斥
在任什么时候刻最多只能有一个执行单元得到锁
要求持有锁的处理器所占用的时间尽量短
等待锁的线程进入忙循环

补充：
___________________windows

临界区和互斥：对于某些全局资源，多个并发执行的线程在访问这些资源时，操做系统可能会交错执行多个并发线程的访问指令，一个错误的指令顺序可能会致使最终的结果错误。多个线程对共享的资源的访问指令构成了一个临界区（critical section），这个临界区不该该和其余线程的交替执行，确保每一个线程执行临界区时能对临界区里的共享资源互斥的访问。安全

回到顶部(go to top)

二自旋锁较互斥锁之类同步机制的优点

2.1 休眠与忙循环

___________________并发

互斥锁得不到锁时，线程会进入休眠，这类同步机制都有一个共性就是一旦资源被占用都会产生任务切换，任务切换涉及不少东西的(保存原来的上下文，按调度算法选择新的任务，恢复新任务的上下文，还有就是要修改cr3寄存器会致使cache失效)这些都是须要大量时间的，所以用互斥之类来同步一旦涉及到阻塞代价是十分昂贵的。函数

一个互斥锁来控制2行代码的原子操做，这个时候一个CPU正在执行这个代码，另外一个CPU也要进入，另外一个CPU就会产生任务切换。为了短短的两行代码就进行任务切换执行大量的代码，对系统性能不利，另外一个CPU还不如直接有条件的死循环，等待那个CPU把那两行代码执行完。post

2.2 自旋过程

___________________性能

当锁被其余线程占有时，获取锁的线程便会进入自旋，不断检测自旋锁的状态。一旦自旋锁被释放，线程便结束自旋，获得自旋锁的线程即可以执行临界区的代码。对于临界区的代码必须短小，不然其余线程会一直受到阻塞，这也是要求锁的持有时间尽可能短的缘由！

回到顶部(go to top)

三 windows驱动程序中自旋锁的使用

3.1 初始化自旋锁

___________________

在windows下，自旋锁用一个名为KSPIN_LOCK的结构体进行表示。

VOID KeInitializeSpinLock(
_Out_ PKSPIN_LOCK SpinLock
);

注意：
存储KSPIN_LOCK变量必须是常驻在内存的，通常能够放在设备对象的设备扩展结构体中，控制对象的控制扩展中，或者调用者申请的非分页内存池中。
可运行在任意IRQL中。

3.2 申请自旋锁

___________________

VOID KeAcquireSpinLock(
  _In_  PKSPIN_LOCK SpinLock,
  _Out_ PKIRQL      OldIrql
);

SpinLock：指向通过KeInitializeSpinLock的结构体
OldIrql：用于保存当前的中断请求级

注意：
当使用全局变量存储 OldIrql时，不一样的锁最好不要共用一个全局块，不然很容易引发竞争问题（race condition）。

3.3 释放自旋锁

___________________

VOID KeReleaseSpinLock(
  _Inout_ PKSPIN_LOCK SpinLock,
  _In_    KIRQL       NewIrql
);

SpinLock：指向通过KeInitializeSpinLock的结构体
NewIrql ：KeAcquireSpinLock保存当前的中断请求级

注意
运行的IRQL = DISPATCH_LEVEL

回到顶部(go to top)

四 windows下自旋锁的实现

4.1 KSPIN_LOCK结构体

___________________

KSPIN_LOCK实际是一个操做系统相关的无符号整数，32位系统上是32位的unsigned long，64位系统则定义为unsigned __int64。
在初始化时，其值被设置为0，为空闲状态。

4.2 KeInitializeSpinLock

___________________

FORCEINLINE
VOID
NTAPI
KeInitializeSpinLock (
    __out PKSPIN_LOCK SpinLock
    ) 
{
    *SpinLock = 0;    //将SpinLock初始化为0，表示锁的状态为空闲状态
}

4.3 KeAcquireSpinLock

___________________

4.3.1 单处理器

wdm.h中是这样定义的：

#define KeAcquireSpinLock(SpinLock, OldIrql) \
    *(OldIrql) = KeAcquireSpinLockRaiseToDpc(SpinLock)

很明显，核心的操做对象是SpinLock，同时也与IRQL有关。

若是当前的IRQL为PASSIVEL_LEVEL，那么首先会提高IRQL到DISPATCH_LEVEL，而后调用KxAcquireSpinLock()。

若是当前的IRQL为DISPATCH_LEVEL，那么就调用KeAcquireSpinLockAtDpcLevel，省去提高IRQL一步。

由于线程调度也是发生在DISPATCH_LEVEL，因此提高IRQL以后当前处理器上就不会发生线程切换。单处理器时，当前只能有一个线程被执行，而这个线程提高IRQL至DISPATCH_LEVEL以后又不会由于调度被切换出去，天然也能够实现咱们想要的互斥“效果”，其实只操做IRQL便可，无需SpinLock。实际上单核系统的内核文件ntosknl.exe中导出的有关SpinLock的函数都只有一句话，就是return。

4.3.2 多处理器

而多处理器呢？提高IRQL只会影响到当前处理器，保证当前处理器的当前线程不被切换。

__forceinline
KIRQL
KeAcquireSpinLockRaiseToDpc (
    __inout PKSPIN_LOCK SpinLock
    )
{

    KIRQL OldIrql;
    //
    // Raise IRQL to DISPATCH_LEVEL and acquire the specified spin lock.
    //
    OldIrql = KfRaiseIrql(DISPATCH_LEVEL);     //提高IRQL
    KxAcquireSpinLock(SpinLock);    //获取自旋锁
    return OldIrql;
}

其中用于获取自旋锁的KxAcquireSpinLock函数：

__forceinline
VOID
KxAcquireSpinLock (
    __inout PKSPIN_LOCK SpinLock
    )
{
    if (InterlockedBitTestAndSet64((LONG64 *)SpinLock, 0))//64位函数
    {

        KxWaitForSpinLockAndAcquire(SpinLock);  //CPU空转进行等待
    }
}

KxAcquireSpinLock（）函数先测试锁的状态。若锁空闲，则SpinLock为0，那么InterlockedBitTestAndSet()将返回0，并使SpinLock置位，再也不为0。这样KxAcquireSpinLock()就成功获得了锁，并设置锁为占用状态（*SpinLock不为0），函数返回。若锁已被占用呢？InterlockedBitTestAndSet()将返回1，此时将调用KxWaitForSpinLockAndAcquire()等待并获取这个锁。这代表，SPIN_LOCK为0则锁空闲，非0则已被占有。

InterlockedBitTestAndSet64()函数的32位版本以下：

BOOLEAN
FORCEINLINE
InterlockedBitTestAndSet (
    IN LONG *Base,
    IN LONG Bit
    )
{
    
__asm {
           mov eax, Bit
           mov ecx, Base
           lock bts [ecx], eax
           setc al
    };
}

关键就在bts指令，是一个进行位测试并置位的指令。这里在进行关键的操做时有lock前缀，保证了多处理器安全。

4.4 KxReleaseSpinLock

___________________

__forceinline
VOID
KxReleaseSpinLock (
   __inout PKSPIN_LOCK SpinLock
   )
{
   InterlockedAnd64((LONG64 *)SpinLock, 0);//释放时进行与操做设置其为0
}

4.5 真实系统上的实现

___________________

好了，对于自旋锁的初始化、获取、释放，都有了了解。可是只是谈谈原理，看看WRK，彷佛有种纸上谈兵的感受？那就实战一下，看看真实系统中是如何实现的。以双核系统中XP SP2下内核中关于SpinLock的实现细节为例：
用IDA分析双核系统的内核文件ntkrnlpa.exe，关于自旋锁操做的两个基本函数是KiAcquireSpinLock和KiReleaseSpinLock，其它几个相似。

.text:004689C0 KiAcquireSpinLock proc near             ; CODE XREF: 
sub_416FEE+2D p
.text:004689C0                                         ; sub_4206C0+5 j ...
.text:004689C0                 lock bts dword ptr [ecx], 0
.text:004689C5                 jb      short loc_4689C8
.text:004689C7                 retn
.text:004689C8 ; ---------------------------------------------------------------------------
.text:004689C8
.text:004689C8 loc_4689C8:                             ; CODE XREF: KiAcquireSpinLock+5 j
.text:004689C8                                         ; KiAcquireSpinLock+12 j
.text:004689C8                 test    dword ptr [ecx], 1
.text:004689CE                 jz      short KiAcquireSpinLock
.text:004689D0                 pause
.text:004689D2                 jmp     short loc_4689C8
.text:004689D2 KiAcquireSpinLock endp

代码比较简单，还原成源码是这样子的：

void __fastcall KiAcquireSpinLock(int _ECX)
{
  while ( 1 )
  {
    __asm { lock bts dword ptr [ecx], 0 }
    if ( !_CF )
      break;
    while ( *(_DWORD *)_ECX & 1 )
      __asm { pause }//应是rep nop，IDA将其翻译成pause
  }
}

fastcall方式调用，参数KSPIN_LOCK在ECX中，能够看到是一个死循环，先测试其是否置位，若否，则CF将置0，并将ECX置位，即获取锁的操做成功；如果，即锁已被占有，则一直对其进行测试并进入空转状态，这和前面分析的彻底一致，只是代码彷佛更精炼了一点，毕竟是实用的玩意嘛。
再来看看释放时：

.text:004689E0                 public KiReleaseSpinLock
.text:004689E0 KiReleaseSpinLock proc near             ; CODE XREF: sub_41702E+E p
.text:004689E0                                         ; sub_4206D0+5 j ...
.text:004689E0                 mov     byte ptr [ecx], 0
.text:004689E3                 retn
.text:004689E3 KiReleaseSpinLock endp

这个再清楚不过了，直接设置为0就表明了将其释放，此时那些如虎狼般疯狂空转的其它处理器将立刻获知这一信息，因而，下一个获取、释放的过程开始了。这就是最基本的自旋锁，其它一些自旋锁形式是对这种基本形式的扩充。好比排队自旋锁，是为了解决多处理器竞争时的无序状态等等，很少说了。
如今对自旋锁可谓真的是明明白白了，以前我犯的错误就是觉得用了自旋锁就能保证多核同步，其实不是的，用自旋锁来保证多核同步的前提是你们都要用这个锁。若当前处理器已占有自旋锁，只有别的处理器也来请求这个锁时，才会进入空转，不进行别的操做，这时你的操做将不会受到干扰。

参考连接：
【原创】明明白白自旋锁
 Linux 内核的排队自旋锁(FIFO Ticket Spinlock)
Linux 内核的同步机制，第 1 部分

线程同步之详解自旋锁

一 什么是自旋锁

二 自旋锁较互斥锁之类同步机制的优点

2.1 休眠与忙循环

2.2 自旋过程

三 windows驱动程序中自旋锁的使用

3.1 初始化自旋锁

3.2 申请自旋锁

3.3 释放自旋锁

四 windows下自旋锁的实现

4.1 KSPIN_LOCK结构体

4.2 KeInitializeSpinLock

4.3 KeAcquireSpinLock

4.3.1 单处理器

4.3.2 多处理器

4.4 KxReleaseSpinLock

4.5 真实系统上的实现

一什么是自旋锁

二自旋锁较互斥锁之类同步机制的优点