BlockingQueue（阻塞队列）基本使用指南

// 将指定的元素插入到队列的尾部，如果队列满了，那么会阻塞，直到队列中有元素被取出。注：不允许添加null元素
void put(E e)
// 如果插入成功则返回 true，若队列已满则抛出 IllegalStateException 异常  
boolean add(E e)
// 如果插入成功则返回 true，若队列已满则返回 false  
boolean offer(E e)
// 如果插入成功则返回 true，若队列已满则阻塞指定时间直到队列中有元素被取出，超时则返回 false
boolean offer(E e, long timeout, TimeUnit unit)

// 获取队列的头部元素并将其删除，在队列为空时会阻塞，直到队列中有元素可取  
E take()
// 检索并删除队列的头部，如果没有元素，则等待指定时间以使元素可用，如果超时，则返回 null
E poll(long timeout, TimeUnit unit)
// 一次性从 BlockingQueue 获取所有可用的数据对象（可以指定获取数据的个数）
// 注：可以提升获取数据效率；不需要多次分批加锁或释放锁
int drainTo(Collection<? super E> c)
int drainTo(Collection<? super E> c, int maxElements)

// 元素数组，其长度在构造方法中指定
final Object[] items;
// 队列中实际的元素数量
int count;
// 保护所有通道的主锁
final ReentrantLock lock;
// 等待take条件的队列
private final Condition notEmpty;
// 等待put条件的队列
private final Condition notFull;

public void put(E e) throws InterruptedException {
    // 检查元素是否为null，如果是，抛出NullPointerException
    Objects.requireNonNull(e);
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lockInterruptibly();
    try {
        // 当队里中的元素数量等于数组长度，则队列已满，阻塞，等待队列成为不满状态
        while (count == items.length)
            notFull.await();
        // 将元素入队
        enqueue(e);
    } finally {
        // 释放锁
        lock.unlock();
    }
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lockInterruptibly();
    try {
        // 当队列中元素数量为0时，则进入阻塞状态
        while (count == 0)
            notEmpty.await();
        // 队列不为空是，调用dequeue()出队
        return dequeue();
    } finally {
        // 释放锁
        lock.unlock();
    }
}

// 容量限制，如果没有指定，则为 Integer.MAX_VALUE
private final int capacity;
// 当前队列中的元素数量
// count只能在两个地方变化，一个是入队的方法（进行+1操作），另一个是出队的方法（进行-1操作），而AtomicInteger是原子安全的，所以也就确保了底层队列的数据同步。
private final AtomicInteger count = new AtomicInteger();
// 队列头节点，始终满足head.item == null
transient Node<E> head;
// 队列的尾节点，始终满足last.next == null
private transient Node<E> last;
// 由 take、poll 等持有的锁
private final ReentrantLock takeLock = new ReentrantLock();
// 当队列为空时，保存执行出队的线程
private final Condition notEmpty = takeLock.newCondition();
// 由 put、offer 等持有的锁
private final ReentrantLock putLock = new ReentrantLock();
// 当队列满时，保存执行入队的线程
private final Condition notFull = putLock.newCondition();

// 在此队列的尾部插入指定元素，如有必要，等待空间可用。
public void put(E e) throws InterruptedException {
    // 不允许元素为null
    if (e == null) throw new NullPointerException();
    int c = -1;
    // 以当前元素新建一个节点
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    // 获得入队的锁
    putLock.lockInterruptibly();
    try {
        // 如果队列已满，那么将该线程加入到Condition的等待队列中
        while (count.get() == capacity) {
            notFull.await();
        }
        // 当队列未满，然后有出队线程取出导致，将节点入队
        enqueue(node);
        // 得到插入之前队列的元素个数。getAndIncrement返回的是 +1 前的值
        c = count.getAndIncrement();
        // 如果还可以插入元素，那么释放等待的入队线程
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        // 释放入队的锁
        putLock.unlock();
    }
    // 如果插入队列之前元素个数为0，插入后就通知出队线程队列非空
    if (c == 0)
        signalNotEmpty();
}

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    // 获取takeLock锁
    takeLock.lockInterruptibly();
    try {
        // 如果队列中元素数量为0，则将出队线程加入到notEmpty队列中进行等待
        while (count.get() == 0) {
            notEmpty.await();
        }
        // 得到到队头的元素
        x = dequeue();
        // 得到出队列前元素的个数。getAndDecrement返回的是 -1 前的值
        c = count.getAndDecrement();
        // 如果出队列前的元素数量大于1，那说明还可以继续取，那就释放在notEmpty队列的第一个线程
        if (c > 1)
            notEmpty.signal();
    } finally {
        // 释放出队锁
        takeLock.unlock();
    }
    // 如果出队前队列是满的，那现在取走一个元素了，队列就不满了，就可以去通知等待中的入队线程了。
    if (c == capacity)
        signalNotFull();
    return x;
}

public boolean remove(Object o) {
    // 因为队列不包含null元素，返回false
    if (o == null) return false;
    // 获取两把锁
    fullyLock();
    try {
        // 从头的下一个节点开始遍历
        for (Node<E> trail = head, p = trail.next;
             p != null;
             trail = p, p = p.next) {
            // 如果匹配，那么将节点从队列中移除，trail表示需要删除节点的前一节点
            if (o.equals(p.item)) {
                unlink(p, trail);
                return true;
            }
        }
        return false;
    } finally {
        // 释放两把锁
        fullyUnlock();
    }
}

/**
 * 锁定以防止 put 和 take.
 */
void fullyLock() {
    putLock.lock();
    takeLock.lock();
}
/**
 * 解锁以允许 put 和 take.
 */
void fullyUnlock() {
    takeLock.unlock();
    putLock.unlock();
}