LinkedBlockingQueue是一个可以有界、也可以无界的阻塞队列，以FIFO（先进先出）的方式访问队列。
head是队首节点，是进入队列时间最长的节点，tail是队尾节点，是进入队列时间最短的节点。
节点从队尾加入队列，从head出队。
LinkedBlockingQueue#主要属性
节点：通过内部类Node定义节点：
static class Node {
E item;
Node next;
Node(E x) { item = x; }
} 很简单，主要属性就两个：
next:下一节点。
item：节点包含的数据。
capacity：队列容量，无界队列值为Integer.MAX_VALUE。
count：队列当前节点数，AtomicInteger类型。
head：头节点。
last：尾结点。
takeLock：ReentrantLock，出队锁，也就是从队列获取数据的锁。
notEmpty：takeLock的Condition，协助获取数据的线程排队。
putLock：ReentrantLock，入队锁，数据加入队列的锁。
notFull：putLock的Condition，协助加入队列的线程排队。
构造方法
无参构造方法创建一个无边界空队列。
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}带容量参数capacity的构造方法创建一个有界空队列
public LinkedBlockingQueue(int capacity) {
if (capacity (null);
}集合参数构造器创建一个无界队列，将参数的集合初始化到队列中：
public LinkedBlockingQueue(Collection extends E> c) {
this(Integer.MAX_VALUE);
final ReentrantLock putLock = this.putLock;
putLock.lock(); // Never contended, but necessary for visibility
try {
int n = 0;
for (E e : c) {
if (e == null)
throw new NullPointerException();
if (n == capacity)
throw new IllegalStateException("Queue full");
enqueue(new Node(e));
++n;
}
count.set(n);
} finally {
putLock.unlock();
}
} 需要注意创建的队列中必然会包含一个dummy性质的head节点，所以出队列的时候这个head节点肯定也需要跳过。
put方法
元素加入队列的put方法，代码也比较简单：
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
// Note: convention in all put/take/etc is to preset local var
// holding count negative to indicate failure unless set.
int c = -1;
Node node = new Node(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try {
while (count.get() == capacity) {
notFull.await();
}
enqueue(node);
c = count.getAndIncrement();
if (c + 1 首先创建Node，并尝试通过putLock.lockInterruptibly();为当前线程获取对队列的写入锁。如果获取到则会立即返回，否则当前线程阻塞等待。
拿到写入锁之后，判断如果当前队列已达容量上线（count.get() == capacity）的话，在notFull上阻塞等待。
否则，如果容量未满或者其他出队线程（从队列take数据的线程成功拿走数据之后）释放出来队列容量后唤醒当前线程后，当前节点enqueue(node)加入队列尾部。然后累加当前队列容量count，并判断如果容量未满的话，唤醒在notFull上等待容量的其他进程。
之后释放putLock锁。
最后，如果加入的节点是队列的第一个节点（c==0,空队列加入），这种情况下可能会有等待take数据的线程在阻塞等待，所以调用signalNotEmpty()唤醒阻塞的take线程。
take方法
获取数据的take方法：
public E take() throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
while (count.get() == 0) {
notEmpty.await();
}
x = dequeue();
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
if (c == capacity)
signalNotFull();
return x;
}首先获取takeLock，获取不到则阻塞等待，获取到则立即返回。
拿到take锁之后，判断如果当前队列是空队列（count.get() == 0）的话，在notEmpty上阻塞等待。
否则，如果队列不空或者其他写入线程（参考put方法，put完成之后唤醒take阻塞线程）写入队列后唤醒当前线程后，调用dequeue方法获取数据。然后重新计算（减）当前队列容量count，并判断如果队列不空的话，唤醒在notEmpty上等待数据的其他take进程。
之后释放takeLock锁。
最后，如果take之前队列已满（c == capacity），这种情况下可能会有等待put数据的线程在阻塞等待，signalNotFull()唤醒阻塞的put线程。
最后将通过dequeue()方法取出的数据返回。
dequeue()方法
去head的次节点，获取该节点的item返回，之后头节点移出队列，次节点变成头节点，并且将变成头节点的次节点（此时其数据item已经被获取到）item置空。
private E dequeue() {
// assert takeLock.isHeldByCurrentThread();
// assert head.item == null;
Node h = head;
Node first = h.next;
h.next = h; // help GC
head = first;
E x = first.item;
first.item = null;
return x;
} 从出队方法dequeue()我们需要明白以下两点：
- 数据是从次节点（头节点的next节点）获取到的，因为头节点是dummy节点
- 头节点移出队列，次节点清理变为dummy节点之后，再变为头节点（勇敢的站在头部装B）
小结
比SynchronousQueue的源码简单多了。不过我们只分析了他的两个主要方法，对于集合类的其他方法，LinkedBlockingQueue也是支持的，代码逻辑也都相对比较简单，需要注意某些操作比如remove、contains等是需要同时获取putLock和takeLock的。其他的写入方法比如offer、数据获取方法比如poll，代码逻辑和put、take大同小异，很容易理解。
只不过阻塞队列LinkedBlockingQueue也是提供非阻塞方法的，比如poll、offer，如果offer的时候队列已满、或者poll的时候空队列，则立即返回false。
对代码理解有阻碍的地方应该是ReentrantLock和Condition，是理解LinkedBlockingQueue源码的前提。
Thanks a lot!
上一篇 BlockingQueue – 基于TransferQueue的SynchronousQueue
服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
