http://coolshell.cn/articles/8239.html
无锁队列的链表实现
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指针就变了,于是我的CAS返回了false,于是程序再试,直到试成功为止。这个很像我们的抢电话热线的不停重播的情况。
你会看到,为什么我们的“置尾结点”的操作(第12行)不判断是否成功,因为:
- 如果有一个线程T1,它的while中的CAS如果成功的话,那么其它所有的 随后线程的CAS都会失败,然后就会再循环,
- 此时,如果T1 线程还没有更新tail指针,其它的线程继续失败,因为tail->next不是NULL了。
- 直到T1线程更新完tail指针,于是其它的线程中的某个线程就可以得到新的tail指针,继续往下走了。
这里有一个潜在的问题——如果T1线程在用CAS更新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 指针 p 到链表尾。但是这样的fetch会很影响性能。而通实际情况看下来,99.9%的情况不会有线程停转的情况,所以,更好的做法是,你可以接合上述的这两个版本,如果retry的次数超了一个值的话(比如说3次),那么,就自己fetch指针。
好了,我们解决了EnQueue,我们再来看看DeQueue的代码:(很简单,我就不解释了)
DeQueue() //出队列
{
do{
p = head;
if (p->next == NULL){
return ERR_EMPTY_QUEUE;
}
while( CAS(head, p, p->next) != TRUE );
return p->next->value;
}
我们可以看到,DeQueue的代码操作的是 head->next,而不是head本身。这样考虑是因为一个边界条件,我们需要一个dummy的头指针来解决链表中如果只有一个元素,head和tail都指向同一个结点的问题,这样EnQueue和DeQueue要互相排斥了。
CAS的ABA问题
所谓ABA(见维基百科的ABA词条),问题基本是这个样子:
- 进程P1在共享变量中读到值为A
- P1被抢占了,进程P2执行
- P2把共享变量里的值从A改成了B,再改回到A,此时被P1抢占。
- P1回来看到共享变量里的值没有被改变,于是继续执行。
虽然P1以为变量值没有改变,继续执行了,但是这个会引发一些潜在的问题。ABA问题最容易发生在lock free 的算法中的,CAS首当其冲,因为CAS判断的是指针的地址。如果这个地址被重用了呢,问题就很大了。(地址被重用是很经常发生的,一个内存分配后释放了,再分配,很有可能还是原来的地址)
比如上述的DeQueue()函数,因为我们要让head和tail分开,所以我们引入了一个dummy指针给head,当我们做CAS的之前,如果head的那块内存被回收并被重用了,而重用的内存又被EnQueue()进来了,这会有很大的问题。(内存管理中重用内存基本上是一种很常见的行为)
这个例子你可能没有看懂,维基百科上给了一个活生生的例子——
你拿着一个装满钱的手提箱在飞机场,此时过来了一个火辣性感的美女,然后她很暖昧地挑逗着你,并趁你不注意的时候,把用一个一模一样的手提箱和你那装满钱的箱子调了个包,然后就离开了,你看到你的手提箱还在那,于是就提着手提箱去赶飞机去了。
这就是ABA的问题。
解决ABA的问题
维基百科上给了一个解——使用double-CAS(双保险的CAS),例如,在32位系统上,我们要检查64位的内容
1)一次用CAS检查双倍长度的值,前半部是指针,后半部分是一个计数器。
2)只有这两个都一样,才算通过检查,要吧赋新的值。并把计数器累加1。
这样一来,ABA发生时,虽然值一样,但是计数器就不一样(但是在32位的系统上,这个计数器会溢出回来又从1开始的,这还是会有ABA的问题)
当然,我们这个队列的问题就是不想让那个内存重用,这样明确的业务问题比较好解决,论文《Implementing Lock-Free Queues》给出一这么一个方法——使用结点内存引用计数refcnt!
SafeRead(q)
{
loop:
p = q->next;
if (p == NULL){
return p;
}
Fetch&Add(p->refcnt, 1);
if (p == q->next){
return p;
}else{
Release(p);
}
goto loop;
}
其中的 Fetch&Add和Release分是是加引用计数和减引用计数,都是原子操作,这样就可以阻止内存被回收了。
import java.util.concurrent.atomic.AtomicReference;
class Node<E> {
public E value;
public AtomicReference<Node<E>> next;
public Node(E value, Node next) {
this.value = value;
this.next = new AtomicReference<Node<E>>(next);
}
public Node() {
next = new AtomicReference<Node<E>>(null);
}
}
class Writer implements Runnable {
private FreeQueue<Integer> que;
public Writer(FreeQueue<Integer> que) {
this.que = que;
}
@Override
public void run() {
for (int i = 0; i < 100; ++i) {
System.out.println(Thread.currentThread() + " : "+i);
que.offer(new Integer(i));
try {
Thread.sleep(10);
} catch(InterruptedException e) {
}
}
}
}
class Reader implements Runnable {
private FreeQueue<Integer> que;
public Reader(FreeQueue<Integer> que) {
this.que = que;
}
@Override
public void run() {
Integer tmp;
for (int i = 0; i < 100; ) {
if ((tmp = que.pop()) != null ) {
++i;
System.out.println(Thread.currentThread() +" : " + tmp);
try {
Thread.sleep(1);
} catch(InterruptedException e) {
}
}
}
}
}
public class FreeQueue<E> {
private AtomicReference<Node<E>> head ;
private AtomicReference<Node<E>> tail;
public FreeQueue() {
Node<E> dumn = new Node<E>();
head = new AtomicReference<Node<E>>(dumn);
tail = new AtomicReference<Node<E>>(dumn);
}
public boolean offer(E val) {
Node<E> node = new Node<E>(val, null);
Node<E> last;
int count = 0;
for (;;) {
++count;
last = tail.get();
if (count > 4) {
while ((last = last.next.get())!= null) {
last = last.next.get();
}
}
if (last.next.compareAndSet(null, node))
break;
}
tail.compareAndSet(last, node);
return true;
}
public E pop() {
Node<E> top;
for (;;) {
Node<E> dumn = head.get();
top = dumn.next.get();
if (top == null) return null;
if (head.compareAndSet(dumn, top))
break;
}
return top.value;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
FreeQueue<Integer> fq = new FreeQueue<Integer>();
Thread []threads = new Thread[10];
int i =0;
for (;i <5; ++i)
threads[i] = new Thread(new Writer(fq), "writer"+i);
for (;i <10; ++i)
threads[i] = new Thread(new Reader(fq), "reader"+(i-5));
for (Thread thread:threads)
thread.start();
try {
for (Thread thread: threads)
thread.join();
} catch(InterruptedException e) {
}
}
}
用数组实现无锁队列
本实现来自论文《Implementing Lock-Free Queues》
使用数组来实现队列是很常见的方法,因为没有内存的分部和释放,一切都会变得简单,实现的思路如下:
1)数组队列应该是一个ring buffer形式的数组(环形数组)
2)数组的元素应该有三个可能的值:HEAD,TAIL,EMPTY(当然,还有实际的数据)
3)数组一开始全部初始化成EMPTY,有两个相邻的元素要初始化成HEAD和TAIL,这代表空队列。
4)EnQueue操作。假设数据x要入队列,定位TAIL的位置,使用double-CAS方法把(TAIL, EMPTY) 更新成 (x, TAIL)。需要注意,如果找不到(TAIL, EMPTY),则说明队列满了。
5)DeQueue操作。定位HEAD的位置,把(HEAD, x)更新成(EMPTY, HEAD),并把x返回。同样需要注意,如果x是TAIL,则说明队列为空。
算法的一个关键是——如何定位HEAD或TAIL?
1)我们可以声明两个计数器,一个用来计数EnQueue的次数,一个用来计数DeQueue的次数。
2)这两个计算器使用使用Fetch&ADD来进行原子累加,在EnQueue或DeQueue完成的时候累加就好了。
3)累加后求个模什么的就可以知道TAIL和HEAD的位置了。
如下图所示:
还有一种方法是采用disruptor的策略,但是要是实现多读,多写的策略,还是太麻烦,以下的实现只是一个reader,一个writer
class Writer implements Runnable {
private LockFreeQueue<Integer> que;
public Writer(LockFreeQueue<Integer> que) {
this.que = que;
}
@Override
public void run() {
for (int i = 0; i < 1000; ++i) {
System.out.println(Thread.currentThread() + " : "+i);
que.offer(new Integer(i));
}
}
}
class Reader implements Runnable {
private LockFreeQueue<Integer> que;
public Reader(LockFreeQueue<Integer> que) {
this.que = que;
}
@Override
public void run() {
Integer tmp;
for (int i = 0; i < 1000; ) {
if ((tmp = que.pop()) != null ) {
++i;
System.out.println(Thread.currentThread() +" : " + tmp);
}
}
}
}
//must one reader, one writer
public class LockFreeQueue<E> {
private E [] array;
private volatile long tail;
private volatile long head;
public LockFreeQueue(int capacity) {
array = (E [])new Object[capacity];
head = tail = 0;
}
public boolean offer(E val) {
for (;;) {
long curr = tail;
if (curr - array.length >= head) continue;
array[(int)(curr%array.length)] = val;
tail++;
break;
}
return true;
}
public E pop() {
E val = null;
for (;;) {
long curr = head;
if (curr == tail) continue;
val = array[(int)curr%array.length];
++head;
break;
}
return val;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
LockFreeQueue<Integer> que = new LockFreeQueue<Integer>(10);
Thread writer = new Thread(new Writer(que), "writer");
Thread reader = new Thread(new Reader(que), "reader");
writer.start();
reader.start();
try {
writer.join();
reader.join();
} catch (InterruptedException e) {
}
}
}