无锁队列的实现

最新推荐文章于 2023-07-16 17:00:33 发布

sunmenggmail

最新推荐文章于 2023-07-16 17:00:33 发布

阅读量1.1k

点赞数

分类专栏： java c++ 分布式

c++ 同时被 3 个专栏收录

178 篇文章 1 订阅

订阅专栏

java

135 篇文章 2 订阅

订阅专栏

分布式

24 篇文章 0 订阅

订阅专栏

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) {
			
		}
		
	}

}

sunmenggmail

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
无锁队列的实现

http://coolshell.cn/articles/8239.html无锁队列的链表实现EnQueue(x) //进队列{ //准备新加入的结点数据 q = new record(); q->value = x; q->next = NULL; do { p = tail; //取链表尾指针的快照 } wh
复制链接

扫一扫