Java BlockingQueue 源码分析

简介

BlockingQueue 是 Java concurrent包提供的多线程安全的阻塞队列，其子类包括 LinkedBlockingQueue 和 ArrayBlockingQueue。

关键API

说到队列，自然少不了首尾的插入删除操作，BlockingQueue的API中提供了好几种插入删除方法。
这些方法在遇到无法满足的执行条件时，如队列满了（添加元素时）/队列为空（取出元素时），会采取不同的措施：抛出异常，返回false/null，阻塞调用API的线程，等待一定时间等。具体如下表：

Throws exception Special value Blocks Times out Insert add(e) offer(e) put(e) offer(e,time,unit) Remove remove() poll() take() poll(time,unit) Examine element() peek() not applicable not applicable

ArrayBlockingQueue

ArrayBlockingQueue是一个基于数组的阻塞队列，在创建一个ArrayBlockingQueue时，需要提供的一个表示队列大小的参数。

ArrayBlockingQueue是线程安全的，但这是怎么做到的呢？这需要注意类中的三个属性：

    /** Main lock guarding all access */    final ReentrantLock lock;    /** Condition for waiting takes */    private final Condition notEmpty;    /** Condition for waiting puts */    private final Condition notFull;

这里一个锁，两个条件变量，管理所有使用API的线程的互斥和同步。具体的锁和条件变量的理论知识，可以参见相关的操作系统书籍。

offer vs put

    public boolean offer(E e) {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lock();        try {            if (count == items.length)                return false;            else {                insert(e);                return true;            }        } finally {            lock.unlock();        }    }    public void put(E e) throws InterruptedException {        checkNotNull(e);        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == items.length)                notFull.await();            insert(e);        } finally {            lock.unlock();        }    }

可以看到，两个方法中在往队列里添加元素时，都是先对临界区加锁，不同在于，offer方法中若是检测出队列已满，会直接返回false；put方法中，若是检测出队列已满，线程会在 notFull 条件变量中阻塞，这样线程会释放锁，让其他线程进入临界区。以后某个时间，一个线程从队列中取出元素，队列不再为空，并且该线程唤醒在notFull条件变量上阻塞的线程，put方法才有可能完成。

poll vs take

 public E take() throws InterruptedException {        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == 0)                notEmpty.await();            return extract();        } finally {            lock.unlock();        }    }

take的逻辑和put差不多，只不过这次是若队列为空，则线程阻塞在notEmpty 条件变量上，等待其他线程往队列中添加元素，并唤醒在notEmpty上阻塞的线程。

   public E poll() {        final ReentrantLock lock = this.lock;        lock.lock();        try {            return (count == 0) ? null : extract();        } finally {            lock.unlock();        }    }

poll方法在检测到队列为空时，直接返回null，否则取出队头元素。

      public E poll(long timeout, TimeUnit unit) throws InterruptedException {        long nanos = unit.toNanos(timeout);        final ReentrantLock lock = this.lock;        lock.lockInterruptibly();        try {            while (count == 0) {                if (nanos <= 0)                    return null;                nanos = notEmpty.awaitNanos(nanos);            }            return extract();        } finally {            lock.unlock();        }    }

poll 还有个比较有趣的重载实现，这里利用Condition变量的计时器方法awaitNanos 。先将时间大小根据时间单位换算成纳秒的数值，当队列容量为0是，使用Condition.awaitNanos(…)，进行计时，超时后返回null。