LinkedBlockingQueue
LinkedBlockingQueue 是一个使用链表完成队列操作的阻塞队列。 链表是单向链表，而不是双向链表 。
看一下属性：
/** The capacity bound, or Integer.MAX_VALUE if none 容量大小 */ private final int capacity; /** Current number of elements 元素个数，因为有2个锁，存在竞态条件，使用AtomicInteger */ private final AtomicInteger count = new AtomicInteger(0); /** * Head of linked list. * Invariant: head.item == null * 头结点 */ private transient Node<E> head; /** * Tail of linked list. * Invariant: last.next == null * 尾节点 */ 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(); |
ArrayBlockingQueue 只有1个锁，添加数据和删除数据的时候只能有1个被执行，不允许并行执行。
而 LinkedBlockingQueue 有2个锁，放元素锁和取元素锁，添加数据和删除数据是可以并行进行的，当然添加数据和删除数据的时候只能有1个线程各自执行。
add 方法内部调用 offer 方法：
public boolean offer(E e) { if (e == null) throw new NullPointerException(); // 不允许空元素 final AtomicInteger count = this.count; if (count.get() == capacity) // 如果容量满了，返回false return false; int c = -1; Node<E> node = new Node(e); // 容量没满，以新元素构造节点 final ReentrantLock putLock = this.putLock; putLock.lock(); // 放锁加锁，保证调用offer方法的时候只有1个线程 try { // 再次判断容量是否已满，因为可能取元素锁在进行消费数据，没满的话继续执行 if (count.get() < capacity) { enqueue(node); // 节点添加到链表尾部 c = count.getAndIncrement(); // 元素个数+1 if (c + 1 < capacity) // 如果容量还没满 notFull.signal(); // 在放锁的条件对象notFull上唤醒正在等待的线程，表示可以再次往队列里面加数据 } } finally { putLock.unlock(); // 释放放锁，让其他线程可以调用offer方法 } // 由于存在放元素锁和取元素锁，这里可能取元素锁一直在消费数据，count会变化。这里的if条件表示如果队列中还有1条数据 if (c == 0) // 在拿锁的条件对象notEmpty上唤醒正在等待的1个线程，表示队列里还有1条数据，可以进行消费 signalNotEmpty(); return c >= 0; // 添加成功返回true，否则返回false } |
put 方法：
public void put(E e) throws InterruptedException { if (e == null) throw new NullPointerException(); // 不允许空元素 int c = -1; Node<E> node = new Node(e); // 以新元素构造节点 final ReentrantLock putLock = this.putLock; final AtomicInteger count = this.count; putLock.lockInterruptibly(); // 放锁加锁，保证调用put方法的时候只有1个线程 try { while (count.get() == capacity) { // 如果容量满了 notFull.await(); // 阻塞并挂起当前线程 } enqueue(node); // 节点添加到链表尾部 c = count.getAndIncrement(); // 元素个数+1 if (c + 1 < capacity) // 如果容量还没满 // 在放锁的条件对象notFull上唤醒正在等待的线程，表示可以再次往队列里面加数据了，队列还没满 notFull.signal(); } finally { putLock.unlock(); // 释放放锁，让其他线程可以调用put方法 } // 由于存在放锁和拿锁，这里可能拿锁一直在消费数据，count会变化。这里的if条件表示如果队列中还有1条数据 if (c == 0) // 在拿锁的条件对象notEmpty上唤醒正在等待的1个线程，表示队列里还有1条数据，可以进行消费 signalNotEmpty(); } |
ArrayBlockingQueue 中放入数据阻塞的时候，需要消费数据才能唤醒。
而LinkedBlockingQueue中放入数据阻塞的时候，因为它内部有2个锁，可以并行执行放入数据和消费数据，不仅在消费数据的时候进行唤醒插入阻塞的线程，同时在插入的时候如果容量还没满，也会唤醒插入阻塞的线程。
poll 方法：
public E poll() { final AtomicInteger count = this.count; if (count.get() == 0) // 如果元素个数为0 return null; // 返回null E x = null; int c = -1; final ReentrantLock takeLock = this.takeLock; takeLock.lock(); // 拿锁加锁，保证调用poll方法的时候只有1个线程 try { if (count.get() > 0) { // 判断队列里是否还有数据 x = dequeue(); // 删除头结点 c = count.getAndDecrement(); // 元素个数-1 if (c > 1) // 如果队列里还有元素 // 在拿锁的条件对象notEmpty上唤醒正在等待的线程，表示队列里还有数据，可以再次消费 notEmpty.signal(); } } finally { takeLock.unlock(); // 释放拿锁，让其他线程可以调用poll方法 } // 由于存在放锁和拿锁，这里可能放锁一直在添加数据，count会变化。这里的if条件表示如果队列中还可以再插入数据 if (c == capacity) // 在放锁的条件对象notFull上唤醒正在等待的1个线程，表示队列里还能再次添加数据 signalNotFull(); return x; } |
take 方法：
public E take() throws InterruptedException { E x; int c = -1; final AtomicInteger count = this.count; final ReentrantLock takeLock = this.takeLock; takeLock.lockInterruptibly(); // 拿锁加锁，保证调用take方法的时候只有1个线程 try { while (count.get() == 0) { // 如果队列里已经没有元素了 notEmpty.await(); // 阻塞并挂起当前线程 } x = dequeue(); // 删除头结点 c = count.getAndDecrement(); // 元素个数-1 if (c > 1) // 如果队列里还有元素 // 在拿锁的条件对象notEmpty上唤醒正在等待的线程，表示队列里还有数据，可以再次消费 notEmpty.signal(); } finally { takeLock.unlock(); // 释放拿锁，让其他线程可以调用take方法 } // 由于存在放锁和拿锁，这里可能放锁一直在添加数据，count会变化。这里的if条件表示如果队列中还可以再插入数据 if (c == capacity) // 在放锁的条件对象notFull上唤醒正在等待的1个线程，表示队列里还能再次添加数据 signalNotFull(); return x; } |
remove 方法：
public boolean remove(Object o) { if (o == null) return false; fullyLock(); // remove操作要移动的位置不固定，2个锁都需要加锁 try { for (Node<E> trail = head, p = trail.next; // 从链表头结点开始遍历 p != null; trail = p, p = p.next) { if (o.equals(p.item)) { // 判断是否找到对象 unlink(p, trail); // 修改节点的链接信息，同时调用notFull的signal方法 return true; } } return false; } finally { fullyUnlock(); // 2个锁解锁 } } |
LinkedBlockingQueue 的take方法对于没数据的情况下会阻塞，poll方法删除链表头结点，remove方法删除指定的对象。
需要注意的是remove方法由于要删除的数据的位置不确定，需要2个锁同时加锁。
