一、概述
LinkedBlockingQueue是基于链表的阻塞FIFO队列，可以指定一个最大的长度限制以防止过度扩展，未指定情况下其大小为Integer.MAX_VALUE。
二、同步策略
putlock只负责添加，takelock只负责删除。这样添加和删除操作就可以分开做，这样也是其吞吐量高于ArrayBlockingQueue的原因，而对于count则使用一个AtomicInteger来进行同步。但是对于迭代器操作和remove（Object）操作则是不同的，需要同时加上两种锁才行。对于notFull和notEmpty的条件变量这里实际也是分开的。
三、可见性
读者和写者之间的可见性问题，当元素是队尾元素时，获取put锁，并且count更新，随后的读者通过fullLock获得put锁或获得take锁来保证其对于队尾元素的可见性。然后读取n=count.get()，这个保证获得对第n个元素的可见性。
四、源码解析
LinkedBlockingQueue 类中定义的变量有：
/** The capacity bound, or Integer.MAX_VALUE if none */
private final int capacity;
/** Current number of elements */
private final AtomicInteger count = new AtomicInteger(0);
/** Head of linked list */
private transient Node<E> head;
/** Tail of linked list */
private transient Node<E> last;
/** Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();
/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();
/** Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition(); 该类中定义了两个ReentrantLock锁：putLock和takeLock，分别用于put端和take端。也就是说，生成端和消费端各自独立拥有一把锁，避免了读（take）写（put）时互相竞争锁的情况。
public boolean offer(E e)
原理：在队尾插入一个元素， 如果队列没满，立即返回true； 如果队列满了，立即返回false。
/**
* 在队尾插入一个元素， 容量没满，可以立即插入，返回true； 队列满了，直接返回false
* 注：如果使用了限制了容量的队列，这个方法比add()好，因为add()插入失败就会抛出异常
*/
public boolean offer(E e) {
if (e == null)
throw new NullPointerException();
final AtomicInteger count = this.count;// 获取队列中的元素个数
if (count.get() == capacity)// 队列满了
return false;
int c = -1;
final ReentrantLock putLock = this.putLock;
putLock.lock();// 获取入队锁
try {
if (count.get() < capacity) {// 容量没满
enqueue(e);// 入队
c = count.getAndIncrement();// 容量+1，返回旧值（注意）
if (c + 1 < capacity)// 如果添加元素后的容量，还小于指定容量（说明在插入当前元素后，至少还可以再插一个元素）
notFull.signal();// 唤醒等待notFull条件的其中一个线程
}
} finally {
putLock.unlock();// 释放入队锁
}
if (c == 0)// 如果c==0，这是什么情况？一开始如果是个空队列，就会是这样的值，要注意的是，上边的c返回的是旧值
signalNotEmpty();
return c >= 0;
}
/**
* 创建一个节点，并加入链表尾部
* @param x
*/
private void enqueue(E x) {
/*
* 封装新节点，并赋给当前的最后一个节点的下一个节点，然后在将这个节点设为最后一个节点
*/
last = last.next = new Node<E>(x);
}
private void signalNotEmpty() {
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();//获取出队锁
try {
notEmpty.signal();//唤醒等待notEmpty条件的线程中的一个
} finally {
takeLock.unlock();//释放出队锁
}
}public void put(E e)
原理：在队尾插入一个元素，如果队列满了，一直阻塞，直到队列不满了或者线程被中断
/**
* 在队尾插一个元素
* 如果队列满了，一直阻塞，直到队列不满了或者线程被中断
*/
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
int c = -1;
final ReentrantLock putLock = this.putLock;//入队锁
final AtomicInteger count = this.count;//当前队列中的元素个数
putLock.lockInterruptibly();//加锁
try {
while (count.get() == capacity) {//如果队列满了
/*
* 加入notFull等待队列，直到队列元素不满了，
* 被其他线程使用notFull.signal()唤醒
*/
notFull.await();
}
enqueue(e);//入队
c = count.getAndIncrement();//入队数量+1
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
}
public E 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（即被其他线程唤醒）
* （唤醒其实就是，有线程将一个元素入队了，然后调用notEmpty.signal()唤醒其他等待这个条件的线程，同时队列也不空了）
*/
notEmpty.await();
}
x = dequeue();//出队
c = count.getAndDecrement();//元素数量-1
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
if (c == capacity)
signalNotFull();
return x;
}
/**
* 从队列头部移除一个节点
*/
private E dequeue() {
Node<E> h = head;//获取头节点：x==null
Node<E> first = h.next;//将头节点的下一个节点赋值给first
h.next = h; // 将当前将要出队的节点置null（为了使其做head节点做准备）
head = first;//将当前将要出队的节点作为了头节点
E x = first.item;//获取出队节点的值
first.item = null;//将出队节点的值置空
return x;
}
private void signalNotFull() {
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
notFull.signal();
} finally {
putLock.unlock();
}
}
public E poll()
原理：如果没有元素，直接返回null；如果有元素，出队
/**
* 出队：
* 1、如果没有元素，直接返回null
* 2、如果有元素，出队
*/
public E poll() {
final AtomicInteger count = this.count;// 获取元素数量
if (count.get() == 0)// 没有元素
return null;
E x = null;
int c = -1;
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();// 获取出队锁
try {
if (count.get() > 0) {// 有元素
x = dequeue();// 出队
// 元素个数-1（注意：该方法是一个无限循环，直到减1成功为止，且返回旧值）
c = count.getAndDecrement();
if (c > 1)// 还有元素（如果旧值c==1的话，那么通过上边的操作之后，队列就空了）
notEmpty.signal();// 唤醒等待在notEmpty队列中的其中一条线程
}
} finally {
takeLock.unlock();// 释放出队锁
}
if (c == capacity)// c == capacity是怎么发生的？如果队列是一个满队列，注意：上边的c返回的是旧值
signalNotFull();
return x;
}五、总结
1、具体入队与出队的原理图：
图中每一个节点前半部分表示封装的数据x，后边的表示指向的下一个引用。
1.1、初始化
初始化之后，初始化一个数据为null，且head和last节点都是这个节点。
1.2、入队两个元素过后
1.3、出队一个元素后
表面上看，只是将头节点的next指针指向了要删除的x1.next，事实上这样我觉的就完全可以，但是jdk实际上是将原来的head节点删除了，而上边看到的这个head节点，正是刚刚出队的x1节点，只是其值被置空了。
2、三种入队对比：
- offer(E e)：如果队列没满，立即返回true； 如果队列满了，立即返回false-->不阻塞
- put(E e)：如果队列满了，一直阻塞，直到队列不满了或者线程被中断-->阻塞
- offer(E e, long timeout, TimeUnit unit)：在队尾插入一个元素,，如果队列已满，则进入等待，直到出现以下三种情况：-->阻塞
- 被唤醒
- 等待时间超时
- 当前线程被中断
3、三种出队对比：
- poll()：如果没有元素，直接返回null；如果有元素，出队
- take()：如果队列空了，一直阻塞，直到队列不为空或者线程被中断-->阻塞
- poll(long timeout, TimeUnit unit)：如果队列不空，出队；如果队列已空且已经超时，返回null；如果队列已空且时间未超时，则进入等待，直到出现以下三种情况：
- 被唤醒
- 等待时间超时
- 当前线程被中断
4、ArrayBlockingQueue与LinkedBlockingQueue对比
- ArrayBlockingQueue：
- 一个对象数组+一把锁+两个条件
- 入队与出队都用同一把锁
- 在只有入队高并发或出队高并发的情况下，因为操作数组，且不需要扩容，性能很高
- 采用了数组，必须指定大小，即容量有限
- LinkedBlockingQueue：
- 一个单向链表+两把锁+两个条件
- 两把锁，一把用于入队，一把用于出队，有效的避免了入队与出队时使用一把锁带来的竞争。
- 在入队与出队都高并发的情况下，性能比ArrayBlockingQueue高很多
- 采用了链表，最大容量为整数最大值，可看做容量无限