利用CAS实现线程安全的无锁队列

最新推荐文章于 2024-05-06 10:36:11 发布

nguliu

最新推荐文章于 2024-05-06 10:36:11 发布

阅读量1.5k

点赞数

分类专栏：数据结构及算法

本文链接：https://blog.csdn.net/qq_40843865/article/details/90734118

版权

数据结构及算法专栏收录该内容

4 篇文章 1 订阅

订阅专栏

1. 关于CAS等原子操作

在开始说无锁队列之前，我们需要知道一个很重要的技术就是CAS操作——Compare And Set 或是 Compare And Swap，比较并交换是原子操作的一种，可用于在多线程编程中实现不被打断的数据交换操作，从而避免多线程同时改写某一数据时由于执行顺序不确定性以及中断的不可预知性产生的数据不一致问题。该操作通过将内存中的值与指定值oldval进行比较，当内存中的值与oldval一样时将内存中的值替换为新值newval。 现在几乎所有的CPU指令都支持CAS的原子操作，X86下对应的是 CMPXCHG 汇编指令。有了这个原子操作，我们就可以用其来实现各种无锁（lock free）的数据结构。

这个操作用C语言来描述就是下面这个样子：（代码来自Wikipedia的Compare And Swap词条）意思就是说，看一看内存*reg里的值是不是oldval，如果是的话，则对其赋值newval，但这整个操作是原子的。
（这里返回old_reg_val是为了方便调用者使用）

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* reg, int oldval, int newval)
{
	if (*reg == oldval) {
		*reg = newval;
		return true;
	}
	return false;
}

与CAS相似的还有下面的原子操作：

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

注：在实际的C/C++程序中，CAS的各种实现版本如下：

1）GCC的CAS
GCC4.1+版本中支持CAS的原子操作（完整的原子操作可参看 GCC Atomic Builtins）

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

2）Windows的CAS
在Windows下，你可以使用下面的Windows API来完成CAS：（完整的Windows原子操作可参看MSDN的InterLocked Functions）

InterlockedCompareExchange ( __inout LONG volatile *Target,
                             __in LONG Exchange,
                             __in LONG Comperand);

3) C++11中的CAS
C++11中的STL中的atomic类的函数可以让你跨平台。（完整的C++11的原子操作可参看 Atomic Operation Library）

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 );

2. 无锁队列的链表实现

我们先来看一下进队列用CAS实现的方式：

EnQueue(x) //进队列
{
    //准备新加入队列的节点
    newNode = new record();
    newNode->value = x;
    newNode->next = NULL;
 
    do {
        p = tail;	 //p指向链表尾节点
    } while( CAS(p->next, NULL, newNode) != true); //当p->next==NULL时将p->next设为newNode，并返回true
 
    CAS(tail, p, newNode);	 //同样利用CAS更新尾指针
}

我们可以看到，程序中的那个 do- while 的 Retry-Loop。就是说，很有可能我在准备在队列尾加入结点时，别的线程已经加成功了，于是tail指针就变了，于是我的CAS返回了false，于是程序再试，直到试成功为止。这个很像我们的抢电话热线的不停重播的情况。

你会看到，为什么我们的“置尾结点”的操作（第12行）不判断是否成功，因为：

如果有一个线程T1，它的while中的CAS如果成功的话，那么其它所有的随后线程的CAS都会失败，然后就会再循环。
此时，如果T1 线程还没有更新tail指针，其它的线程继续失败，因为tail->next不是NULL了。
直到T1线程更新完tail指针，于是其它的线程中的某个线程就可以得到新的tail指针，继续往下走了。

这里有一个潜在的问题——如果T1线程在 while中的CAS成功之后-更新tail指针之前停掉或是挂掉了，那么其它线程就进入死循环了。下面是改良版的EnQueue()

EnQueue(x) //进队列改良版
{
    newNode = new record();
    newNode->value = x;
    newNode->next = NULL;
 
    p = tail;
    oldp = p;
    do {
        while (p->next != NULL)
            p = p->next;
    } while( CAS(p->next, NULL, newNode) != true); //如果没有把结点链在表尾，再试
 
    CAS(tail, oldp, newNode); //置尾结点
}

我们让每个线程，自己fetch 指针 p 到链表尾。但是这样的fetch会很影响性能。而通实际情况看下来，99.9%的情况不会有线程停转的情况，所以，更好的做法是，你可以结合上述的这两个版本，如果retry的次数超了一个值的话（比如说3次），那么，就自己fetch指针。

好了，我们解决了EnQueue，我们再来看看DeQueue的代码：

DeQueue() //出队列
{
    do {
        p = head->next;		//使用了dummyHead
        if (p == NULL) {
            return ERR_EMPTY_QUEUE;
        }
    } while( CAS(head->next, p, p->next) != true);
    return p->value;
}

我们可以看到，DeQueue的代码操作的是 head->next，而不是head本身。这样考虑是因为一个边界条件，我们需要一个dummy头节点来解决链表中如果只有一个元素，head和tail都指向同一个结点的问题，这样EnQueue和DeQueue要互相排斥了。
注：下图的tail正处于更新之前的状态
在这里插入图片描述

3. CAS的ABA问题

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

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

虽然P1以为变量值没有改变，继续执行了，但是这个会引发一些潜在的问题。ABA问题最容易发生在lock free 的算法中的，CAS首当其冲，因为CAS判断的是指针的地址。如果这个地址被重用了呢，问题就很大了。（地址被重用是很经常发生的，一个内存分配后释放了，再分配，很有可能还是原来的地址）

比如上述的DeQueue()函数，因为我们要让head和tail分开，所以我们引入了一个dummyHead节点，当我们做CAS的之前，如果head的那块内存被回收并被重用了，而重用的内存又被EnQueue()进来了，这会有很大的问题。（内存管理中重用内存基本上是一种很常见的行为）

在维基百科上给了一个很形象的例子——

你拿着一个装满钱的手提箱在飞机场，此时过来了一个火辣性感的美女，然后她很暖昧地挑逗着你，并趁你不注意的时候，
把用一个一模一样的手提箱和你那装满钱的箱子调了个包，然后就离开了，你看到你的手提箱还在那，于是就提着手提箱去赶飞机去了。

这就是ABA的问题

4. 解决ABA的问题

维基百科上给了一个解——使用double-CAS（双保险的CAS），例如，在32位系统上，我们要检查64位的内容

一次用CAS检查双倍长度的值，前半部是指针，后半部分是一个计数器。
只有这两个都一样，才算通过检查，要吧赋新的值。并把计数器累加1。

这样一来，ABA发生时，虽然值一样，但是计数器就不一样（但是在32位的系统上，这个计数器会溢出回来又从1开始的，这还是会有ABA的问题）

这里的问题就是不想让那个内存重用，这样明确的业务问题比较好解决。我们这里使用的是结点内存引用计数refcnt

SafeRead(q)
{
loop:
	p = q->next;
	if (p == NULL){
		return p;
	}
	
	FetchAndAdd(p->refcnt, 1);
	
	if (p == q->next) {
		return p;
	}
	else {
		Release(p);
	}
	goto loop;
}

其中的 FetchAndAdd和Release分是是加引用计数和减引用计数，都是原子操作，这样就可以阻止内存被回收了。

5. 用数组实现无锁队列

使用数组来实现队列是很常见的方法，因为没有内存的分部和释放，一切都会变得简单，实现的思路如下：

数组队列应该是一个ring buffer形式的数组（环形数组）
数组的元素应该有三个可能的值：HEAD，TAIL，EMPTY（当然，还有实际的数据）
数组一开始全部初始化成EMPTY，有两个相邻的元素要初始化成HEAD和TAIL，这代表空队列。
EnQueue操作。假设数据x要入队列，定位TAIL的位置，使用double-CAS方法把(TAIL, EMPTY) 更新成 (x, TAIL)。需要注意，如果找不到(TAIL, EMPTY)，则说明队列满了。
DeQueue操作。定位HEAD的位置，把(HEAD, x)更新成(EMPTY, HEAD)，并把x返回。同样需要注意，如果x是TAIL，则说明队列为空。

算法的一个关键是——如何定位HEAD或TAIL？

1）我们可以声明两个计数器，一个用来计数EnQueue的次数，一个用来计数DeQueue的次数。

2）这两个计算器使用使用Fetch&ADD来进行原子累加，在EnQueue或DeQueue完成的时候累加就好了。

3）累加后求个模什么的就可以知道TAIL和HEAD的位置了。

如下图所示：
在这里插入图片描述