SpinLock 自旋锁, CAS操作（Compare & Set） ABA Problem

SpinLock 自旋锁

spinlock 用于CPU同步, 它的实现是基于CPU锁定数据总线的指令.

当某个CPU锁住数据总线后, 它读一个内存单元(spinlock_t)来判断这个spinlock 是否已经被别的CPU锁住.

如果否, 它写进一个特定值, 表示锁定成功, 然后返回.

如果是, 它会重复以上操作直到成功, 或者spin次数超过一个设定值.

锁定数据总线的指令只能保证一个机器指令内, CPU独占数据总线.

单CPU当然能用spinlock, 但实现上无需锁定数据总线.

spinlock在锁定的时候,如果不成功,不会睡眠,会持续的尝试,

单cpu的时候spinlock会让其它process动不了.

自旋锁是一种保护数据结构或代码片段的原始方式，

在某个时刻只允许一个进程访问临界区内的代码。

一般spinlock实现会有一个参数限定最多持续尝试次数.

超出后, spinlock放弃当前time slice. 等下一次机会.

有三果问题不清楚

1，单CPU内核中，假设好几个内核线程用spinlock共享一块数据，一个时间只有一个线程得到锁，

那是不是其它没有得到锁的线程都在疯狂的自旋中？

2，内核里似乎到处都有spinlock，在单CPU系统下spinlock主要用来做什么呢？

也能用来当数据同步的锁来用？

3，用户空间有spinlock吗？

1. Yes. 但spinlock只适用于short lock.

2. 单CPU, 或SMP, 都是同步锁

3. Yes

1. 通常如果一个线程没有得到锁会调用 sleep() 或者 yield() 之类的函数

让调度器重新进行调度，不会疯狂自旋的。

2. 自旋锁是一种很低级的操作，是为了实现资源的互斥而不是同步，

在单 CPU 中其实可以用关闭中断的方法代替自旋锁，

在多 CPU 中自旋锁必须要实现，这如前面一个朋友所说的，自旋锁需要锁总线，

你可以查看 X86 的 lock 指令和 compare and exchange 指令或者 test and set 指令得到更多的信息。

3. 通常在用户空间不使用自旋锁，在用户空间通常使用 Mutex 互斥，Semaphore 同步。

自旋锁有可能用于实现 Mutex 和 Semaphore.

CAS操作——Compare & Set

或是 Compare & Swap，现在几乎所有的CPU指令都支持CAS的原子操作，

X86下对应的是 CMPXCHG 汇编指令。

有了这个原子操作，我们就可以用其来实现各种无锁（lock free）的数据结构。

这个操作用C语言来描述就是下面这个样子：（代码来自Wikipedia的Compare And Swap词条）

意思就是说，看一看内存*reg里的值是不是oldval，如果是的话，则对其赋值newval。

int compare_and_swap (int* reg, int oldval, int newval)

{

  int old_reg_val = *reg;

  if(old_reg_val == oldval)

     *reg = newval;

  return old_reg_val;

}

这个操作可以变种为返回bool值的形式（返回 bool值的好处在于，可以调用者知道有没有更新成功）

bool compare_and_swap (int*accum, int*dest, int newval)

{

  if( *accum == *dest )

  {

      *dest = newval;

      return true;

  }

  return false;

}

与CAS相似的还有下面的原子操作：（这些东西大家自己看Wikipedia吧）

Fetch And Add，一般用来对变量做 +1 的原子操作
Test-and-set，写值到某个内存位置并传回其旧值。汇编指令BST
Test and Test-and-set，用来低低Test-and-Set的资源争夺情况

cmpxchg是汇编指令

作用：比较并交换操作数.

如：CMPXCHG r/m,r 将累加器AL/AX/EAX/RAX中的值与首操作数（目的操作数）比较，

如果相等，第2操作数（源操作数）的值装载到首操作数，zf置1。

如果不等，首操作数的值装载到AL/AX/EAX/RAX并将zf清0

该指令只能用于486及其后继机型。

第2操作数（源操作数）只能用8位、16位或32位寄存器。

第1操作数（目地操作数）则可用寄存器或任一种存储器寻址方式。

操作伪代码：

IF accumulator == DEST THEN

  ZF <- 1;         // ACC - DEST == 0

  DEST <- SRC;

ELSE

  ZF <- 0;         // ACC - DEST != 0

  accumulator <- DEST;

FI;

CMPXCHG CX,DX

首先进行CMP操作，这个操作就是进行减运算，但不保存结果，只是影响标志位ZF的。AX CX相减为0，ZF置位为1。

CMPXCHG隐含使用EAX寄存器，根据首操作数的位数确定EAX的位数，就是根据CX来确定是AX，

如果是CL，则就是AL，根据CMP结果进行XCHG，相等则第2操作数送到第1操作数，不等则第1操作数送EAX或AX或AL。

象这种隐含使用其他寄存器的指令还有不少。对于哪种操作影响标志位也需要慢慢熟悉。

其实在很久前，CMPXCHG指令是很标准的，它规定第2个操作数必须是EAX/AX/AL，
这样就简单了，先比较2个操作数，如果相等，ZF置1，第2操作数送第1操作数，
如果不等，ZF清0，第1操作数送第2操作数。很标准的“比较交换”。
只不过后来对第2操作数就不做限制必须是EAX/AX/AL了，变成隐含使用

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。

如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。

否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。

（在 CAS 的一些特殊情况下将仅返回 CAS 是否成功，而不提取当前值。）

CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；

否则，不要更改该位置，只告诉我这个位置现在的值即可。”

通常将 CAS 用于同步的方式是从地址 V 读取值 A，执行多步计算来获得新值 B，然后使用 CAS 将 V 的值从 A 改为 B。

如果 V 处的值尚未同时更改，则 CAS 操作成功。

类似于 CAS 的指令允许算法执行读-修改-写操作，而无需害怕其他线程同时修改变量，

因为如果其他线程修改变量，那么 CAS 会检测它（并失败），算法可以对该操作重新计算。

ABA Problem

CAS：对于内存中的某一个值V，提供一个旧值A和一个新值B。

如果提供的旧值V和A相等就把B写入V。这个过程是原子性的。

CAS执行结果要么成功要么失败，对于失败的情形下一班采用不断重试。或者放弃。

ABA：如果另一个线程修改V值, 假设原来是A，先修改成B，再修改回成A。

当前线程的CAS操作无法分辨当前V值是否发生过变化。

关于ABA问题我想了一个例子：

在你非常渴的情况下你发现一个盛满水的杯子，你一饮而尽。之后再给杯子里重新倒满水。

然后你离开，当杯子的真正主人回来时看到杯子还是盛满水，他当然不知道是否被人喝完重新倒满。

解决这个问题的方案的一个策略是每一次倒水假设有一个自动记录仪记录下，

这样主人回来就可以分辨在她离开后是否发生过重新倒满的情况。这也是解决ABA问题目前采用的策略。

CAS的ABA问题

所谓ABA（见维基百科的ABA词条），问题基本是这个样子：

进程P1在共享变量中读到值为A
P1被抢占了，进程P2执行
P2把共享变量里的值从A改成了B，再改回到A，此时被P1抢占。
P1回来看到共享变量里的值没有被改变，于是继续执行。

虽然P1以为变量值没有改变，继续执行了，但是这个会引发一些潜在的问题。

ABA问题最容易发生在lock free 的算法中的，CAS首当其冲，因为CAS判断的是指针的地址。

如果这个地址被重用了呢，问题就很大了。

你拿着一个装满钱的手提箱在飞机场，此时过来了一个火辣性感的美女，然后她很暖昧地挑逗着你，并趁你不注意的时候，

把用一个一模一样的手提箱和你那装满钱的箱子调了个包，然后就离开了，你看到你的手提箱还在那，于是就提着手提箱去赶飞机去了。

这就是ABA的问题。