LinkedBlockingQueue是一个能够有界、也能够无界的阻塞队列，以FIFO（先进先出）的形式拜访队列。
head是队首节点，是进入队列工夫最长的节点，tail是队尾节点，是进入队列工夫最短的节点。
节点从队尾退出队列，从head出队。
LinkedBlockingQueue#次要属性
节点：通过外部类Node定义节点：
static class Node<E> {
E item;
Node<E> 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 <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(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>(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<E> node = new Node<E>(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 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
}首先创立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<E> h = head;
Node<E> 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
发表回复