· 在并发编程中，我们有时候会需要使用到线程安全的队列，而在Java中如果我们需要实现队列可以有两种方式，一种是阻塞式队列。另一种是非阻塞式的队列，阻塞式队列采用锁来实现，而非阻塞式队列则是采用cas算法来保证线程安全的，接下来就让我们来看一下jdk中两种队列的实现方式。
1. ConcurrentLinkedQueue的实现原理
顾名思义，这是一个基于链表结构的队列，它是一个先进先出的队列，当我们添加元素时，添加的元素链接到队列的尾部，当获取元素时返回队列的头部元素。
先看添加队列时ConcurrentLinkedQueue的实现方法offer():
public boolean offer(E e) {
//判断元素是否为空，为空则抛出异常
checkNotNull(e);
//创建一个新的节点 Node中的结构为item(数据) next(下一个节点)
final Node<E> newNode = new Node<E>(e);
//自旋，将节点添加到队列尾部
for (Node<E> t = tail, p = t;;) {
//获取到p的下一个节点，即是当前tail节点的的下一个节点
Node<E> q = p.next;
//如果q为空，表示q的下一个节点为null，直接将当前节点添加到队列尾部
if (q == null) {
// p is last node
//添加节点到队列尾部
if (p.casNext(null, newNode)) {
// Successful CAS is the linearization point
// for e to become an element of this queue,
// and for newNode to become "live".
//第一次进来时p == t，所以这里不会将当前节点设置成tail
if (p != t) // hop two nodes at a time
casTail(t, newNode); // Failure is OK.
return true;
}
// Lost CAS race to another thread; re-read next
}
else if (p == q)
//多线程操作时候，由于poll时候会把老的head变为自引用，然后head的next变为新head，所以这里需要 //重新找新的head，因为新的head后面的节点才是激活的节点
p = (t != (t = tail)) ? t : head;
else
// Check for tail updates after two hops.
p = (p != t && t != (t = tail)) ? t : q;
}
}
首先检查当前进来的元素是否为null,为null则抛出空指针异常。将tail赋值给t和p,无限循环，将当前p.next()赋值给q,如果为空，则将当前节点添加到队列尾部，添加成功则继续看p 是否等于t，第一次进来时是相等的，所以不会调用casTail()方法，直接返回true即可，因为在多线程的环境下，可能会出现线程进入循环时，q不等于空，此时看p == q是否成立，开始必然是不成立的，执行最后一个else,将tal赋值给t,并将q赋值给p,继续循环，此时p的next为空，则执行将节点添加到队列尾部的操作，并且此时的p 不等于t，更新尾节点tail位置为当前新添加的节点。
出队方法poll():
public E poll() {
restartFromHead:
for (;;) {
for (Node<E> h = head, p = h, q;;) {
E item = p.item;
if (item != null && p.casItem(item, null)) {
// Successful CAS is the linearization point
// for item to be removed from this queue.
if (p != h) // hop two nodes at a time
updateHead(h, ((q = p.next) != null) ? q : p);
return item;
}
else if ((q = p.next) == null) {
updateHead(h, p);
return null;
}
else if (p == q)
continue restartFromHead;
else
p = q;
}
}
}
先来个死循环，再来一个死循环将head赋值给h,h 赋值给p, 得到头节点的值保存到item中，当item不为空时，通过cas算法将p节点的item设置为null，设置成功后，判断p是否等于h，等于则更新头节点,并将p.next()赋值给q,当p.next不为空时，头节点设置为q.否则设置为p,如果p.next()为null,则将更新头节点，返回null,如果p==q,自引用了，则重新找新的头节点。
ConcurrentLinkedQueue主要就是利用了cas算法来保证了多线程环境下线程的安全，这样的算法其实性能来说是比较优的，速度相比较阻塞式的算法会更好一些。
2. BlockingQueue
BlockingQueue是一个阻塞式队列，当tack()时队列为空，则它不会返回空或者是抛异常，线程此时会一直等待着，知道队列中存在数据时才会去取出数据，同时put()当队列满了的情况下，也会等待，知道其他线程取出队列中的数据，腾出空间之后再执行入队操作，其实它也提供了add/remove这样的非阻塞式方法的，当队列full或队列为空时，直接抛出异常，这里我们主要说的是它阻塞的情况，主要有put/take()方法。
这里以BlockingQueue的实现类ArrayBlockingQueue源码进行分析。
put():
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
notFull.await();
insert(e);
} finally {
lock.unlock();
}
}
其实这里的实现原理就是生产者与消费者使用Condition实现原理一样，notFull和notEmpty两个Condition，使用可中断锁，count作为元素个数标记，以一个数组来保存元素，当count等于数组长度时，使notFull等待，否则调用insert()方法添加元素。
insert()方法：
private void insert(E x) {
items[putIndex] = x;
putIndex = inc(putIndex);
++count;
notEmpty.signal();
}
这里很简单，将元素保存到数组中，count++，唤醒等待读取元素的线程，告诉它已经有数据了，可以获取了。
take
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
notEmpty.await();
return extract();
} finally {
lock.unlock();
}
}
使用中断锁，当count为0时，表示当前队列中已经没有资源了，所以线程等待，否则就调用extract（）返回数据。
extract():
private E extract() {
final Object[] items = this.items;
E x = this.<E>cast(items[takeIndex]);
items[takeIndex] = null;
takeIndex = inc(takeIndex);
--count;
notFull.signal();
return x;
}
得到takeIndex位置的元素，保存到x中，并且将下表位置的元素置为空,更改takeIndex,count--，唤醒可能由于队列满了的情况下被等待的添加元素的线程，返回x，这样就取到了当前的元素。
这里的实现原理跟生产者/消费者模式一样，同时使用Condition来指定唤醒某些等待的线程，实现了多线程下队列的阻塞和线程安全。
原文 并发编程学习笔记(13)----ConcurrentLinkedQueue(非阻塞队列)和BlockingQueue(阻塞队列)原理