首次接触无锁数据结构的设计，请各位大佬多多指教~~~

CAS(Compare && Swap)原子操作

CAS是无锁(lock free)的数据结构的基础。用伪代码描述：

input: reg, old_val, new_val

/*是old_val， reg替换为new_val，返回为true；否则返回为false*/

if (* reg == old_val) {

* reg == new_val;

return true;

} else {

return false;

}

CAS相似的原子操作：

fetch and add，一般用来对变量做+1的原子操作

test and set， 写值到内存位置并传回其旧值

test test and set : 和双检查锁一样为了减少对锁的多次竞争，对锁的竞争代价比普通判断锁的状态要大，这里需要着重强调，在high level programming的背景下，尽量少用双重检测锁的形式，因为第二次检查和设置并不一定是原子操作。test test and set伪代码(Wikipedia test test and set)如下:

boolean locked := false // shared lock variable

procedure EnterCritical() {

do {

while (locked == true) skip // spin until lock seems free

} while TestAndSet(locked) // actual atomic locking, this cost of step >> the cost above !!!;

}

在此稍微记录一下，

GCC的原子CAS的API

bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...)

type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...)

C++11的CAS

C++11的STL中的atomic类的函数可以跨平台。

template< class T >

bool atomic_compare_exchange_weak( std::atomic* obj,

T* expected, T desired );

template< class T >

bool atomic_compare_exchange_weak( volatile std::atomic* obj,

T* expected, T desired );

无锁队列的链表实现

EnQueue(x) {

// 准备新加入的结点数据

q = new record();

q->value = x;

q->next = NULL;

do {

p = tail; // 链表尾指针的快照

} while( CAS(p->next, NULL, q)!= true)

CAS(tail, p, q);

}

do while的Re-Try-Loop，如果别的进程已经加成功了，tail就变了，p!=tail, p->next!= NULL，那么就重试。

这里存在一个问题，如果在CAS(tail, p, q)之前线程挂掉了或者停掉了，其它线程更新了p->next，却没有更新tail，然后就一直进入死循环。为了解决这个问题，下面推出了改良版的EnQueue()

EnQueue(x)

{

q = new record();

q->value = x;

q->next = NULL;

p = tail;

oldp = p;

do {

while (p->next!= NULL) {

p = p->next;

} while (CAS(p->next, NULL, q)!= TRUE); // 如果没有把结点链在尾上，再试

CAS (tail , oldp, q); // 置尾结点

}

}

fetch会很影响性能， 所以可以结合以上两个版本，如果retry的次数超过一个阈值，那么自己就fetch指针。

但是这里存在一个问题，就oldq能不能及时更新，若不能及时更新，其余线程在插入时会插到未定义的位置。个人觉得还是选择未改良版比较好。

DeQueue // 出队列

DeQueue() {

do {

p = head;

if (p -> next == NULL) {

return ERR_EMPTY_QUEUE;

}

} while ( CAS(head, p, p->next)!= TRUE);

return p->next->value;

}

CAS的ABA问题：

进程p1在共享变量中读到值为A

p1被抢占了，进程p2执行

p2把共享变量里的值从A改成B，再改回到A，此时被p1抢占。

p1回来看到共享变量里的值没有被改变，于是继续执行。

看来好像没有问题，但是上式的CAS其实判断的是指针地址，然而指针内容改变了，不就炸了？这就是内存管理中的重用内存问题。

解决ABA的问题

例如在32位系统上检查64位的内容：

一次用CAS检查双倍长度的值，前半部分是指针，后半部分是一个计数器

只有这两个都一样，才算通过，要用该指针符新的值，计数器加1。

这种方法线程次数上应该也没问题，但是一旦多了，可能会溢出循环计数。

所以有论文提出了使用结点内存的引用计数，这和智能指针没啥区别嘛，但是需要保证加引用计数和减引用计数为原子操作。

用数组实现无锁队列

无锁队列可以用ring buffer实现，定位head和tail可以声明两个计数器，一个用来计数EnQueue的次数，一个用来计数DeQueue的次数，当队列满或空，可以抛出异常，没有内存泄露的问题。

reference