java轻松实现无锁队列

1、什么是无锁(Lock-Free)编程

当谈及 Lock-Free 编程时，我们常将其概念与 Mutex(互斥) 或 Lock(锁) 联系在一起，描述要在编程中尽量少使用这些锁结构，降低线程间互相阻塞的机会，以提高应用程序的性能。类同的概念还有 "Lockless" 和 "Non-Blocking" 等。实际上，这样的描述只涵盖了 Lock-Free编程的一部分内容。本质上说，Lock-Free 编程仅描述了代码所表述的性质，而没有限定或要求代码该如何编写。

基本上，如果程序中的某一部分符合下面的条件判定描述，则我们称这部分程序是符合 Lock-Free的。反过来说，如果某一部分程序不符合下面的条件描述，则称这部分程序是不符合 Lock-Free 的。

上面的英文翻译成中文就是很简单的：如果你的应用程序是多线程并且它们之间都有访问共享内存但是访问时并没有相互阻塞，那它就是lock-free编程。注意lock-free只是强调了编程概念并没指定其具体的实现形式，其强调的概念是「线程间访问共享内存时不会相互阻塞」。那如果没有lock或者Mutex就一定是lock-free编程了吗，看下面的代码片段：

        x = 0;

        while(x == 0){

             x = 1 - x;

        }

假设有线程T1,T2同时调用这段代码，T1,T2都判断x == 0,进行到循环。T1先执行 x = 1 - 0，此时 x = 1后 T2 执行 x = 1 - 1。x = 0。T1,T2此时判断x == 0，结果两者又进入了循环。。。线程T1,T2相互影响，两者都陷入了死循环，这种某种意义也算得上是相互阻塞使线程,所以这不算是lock-free编程。

ok，了解了lock-free编程的相关概念那要怎么实现呢。在开始说无锁队列之前，我们需要知道一个很重要的技术就是CAS操作——Compare & Set，或是 Compare & Swap，现在几乎所有的CPU指令都支持CAS的原子操作，X86下对应的是 CMPXCHG 汇编指令。有了这个原子操作，我们就可以用其来实现各种无锁（lock free）的数据结构。

这个操作用C语言来描述就是下面这个样子：意思就是说，看一看内存*reg里的值是不是oldval，如果是的话，则对其赋值newval。

 

1 2 3 4 5 6 7

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

用JAVA语言则是：

 public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

　　

了解了CAS操作之后实现lock-free数据结构思路是怎样呢？这里就有篇论文讲述了思路：http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.53.8674&rep=rep1&type=pdf。其中里面就提到了如何用数组实现一个lock-free队列。有兴趣的朋友可以参考上面链接阅读里面的第5章节。现在说一下我自己具体的实现思路：

• 数组队列是一个循环数组，队列少用一个元素，当头等于尾标示队空，尾加1等于头标示队满。
• 数组的元素用EMPTY（无数据，标示可以入队）和FULL（有数据，标示可以出队）标记指示，数组一开始全部初始化成 EMPTY标示空队列。
• EnQue 操作：如果当前队尾位置为EMPTY，标示线程可以在当前位置入队，通过CAS原子操作把该位置设置为FULL，避免其它线程操作这个位置，操作完后修改队尾位置。各个线程竞争新的队尾位置。如下图所示：

aaarticlea/png;base64,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" alt="" />

下面是贴上具体的代码：

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReferenceArray;

/**
 * 用数组实现无锁有界队列
 */

public class LockFreeQueue {

    private AtomicReferenceArray atomicReferenceArray;
    //代表为空，没有元素
    private static final  Integer EMPTY = null;
    //头指针,尾指针
    AtomicInteger head,tail;

    public LockFreeQueue(int size){
        atomicReferenceArray = new AtomicReferenceArray(new Integer[size + 1]);
        head = new AtomicInteger(0);
        tail = new AtomicInteger(0);
    }

    /**
     * 入队
     * @param element
     * @return
     */
    public boolean add(Integer element){
        int index = (tail.get() + 1) % atomicReferenceArray.length();
        if( index == head.get() % atomicReferenceArray.length()){
            System.out.println("当前队列已满,"+ element+"无法入队!");
            return false;
        }
        while(!atomicReferenceArray.compareAndSet(index,EMPTY,element)){
            return add(element);
        }
        tail.incrementAndGet(); //移动尾指针
        System.out.println("入队成功!" + element);
        return true;
    }

    /**
     * 出队
     * @return
     */
    public Integer poll(){
        if(head.get() == tail.get()){
            System.out.println("当前队列为空");
            return null;
        }
        int index = (head.get() + 1) % atomicReferenceArray.length();
        Integer ele = (Integer) atomicReferenceArray.get(index);
        if(ele == null){ //有可能其它线程也在出队
            return poll();
        }
        while(!atomicReferenceArray.compareAndSet(index,ele,EMPTY)){
            return poll();
        }
        head.incrementAndGet();
        System.out.println("出队成功!" + ele);
        return ele;
    }

    public void print(){
       StringBuffer buffer = new StringBuffer("[");
       for(int i = 0; i < atomicReferenceArray.length() ; i++){
           if(i == head.get() || atomicReferenceArray.get(i) == null){
               continue;
           }
           buffer.append(atomicReferenceArray.get(i) + ",");
       }
       buffer.deleteCharAt(buffer.length() - 1);
       buffer.append("]");
       System.out.println("队列内容:"    +buffer.toString());

    }

}

　　代码很简单，相应的注释也写上了，相信大家都应该看得懂~。

这里说明一下JDK提供的CAS原子操作类都位于 java.util.concurrent.atomic下面。这里用到的是数组我用的是AtomicReferenceArray类，当然你也可以用AtomicIntegerArray。这里用到了两个原子类的作为指针head,tail，利用mod队列的长度来实现一个循环数组。

下面测试我们的代码：

import java.util.stream.IntStream;

public class LockFreeDemo {
        public static void main(String[] args) {
            LockFreeQueue queue = new LockFreeQueue(5);
            IntStream.rangeClosed(1, 10).parallel().forEach(
                    i -> {
                        if (i % 2 == 0) {
                            queue.add(i);
                        } else {
                            queue.poll();
                        }
                    }
            );
            queue.print();
        }
}

这里面用了JDK8的lambda并行流的特性，起了Ncpu线程去并发得入队和出队。运行结果如下：

入队成功!2
当前队列为空
当前队列为空
入队成功!6
当前队列为空
入队成功!8
出队成功!2
入队成功!10
出队成功!6
入队成功!4
队列内容:[4,8,10]

因为是并发打印，所以打出来的信息整体是无序的，但是对于同一个元素的操作，我们看到是相对有序的~