深入理解阻塞队列（二）——ArrayBlockingQueue源码分析

在深入理解阻塞队列（一）——基本结构中，介绍了BlockingQueue这一接口的子类以及子接口。本文主要就其中的一个实现类：ArrayBlockingQueue进行源码分析，分析阻塞队列的阻塞是如何实现的。

概述

ArrayBlockingQueue底层是使用一个数组实现队列的，并且在构造ArrayBlockingQueue时需要指定容量，也就意味着底层数组一旦创建了，容量就不能改变了，因此ArrayBlockingQueue是一个容量限制的阻塞队列。因此，在队列全满时执行入队将会阻塞，在队列为空时出队同样将会阻塞。

源码分析

重要字段

ArrayBlockingQueue的重要字段有如下几个：

 /** The queued items */
    final Object[] items;

/** Main lock guarding all access */
    final ReentrantLock lock;

    /** Condition for waiting takes */
    private final Condition notEmpty;

    /** Condition for waiting puts */
    private final Condition notFull;

上面代码中的items数组就代表的是队列，ReentrantLock和两个Condition都是用于用于并发的，并且这几个字段都是final的，意味着ArrayBloackingQueue初始化时就必须完成赋值。
ArrayBlockingQueue中有几个int型的字段表示当前操作items数组的索引，如下：

    //记录下一个take、remove、peek的索引
    int takeIndex;

    //记录下一个put、offer、add的索引
    int putIndex;

    //队列中元素的个数
    int count;

构造方法

ArrayBlockingQueue一共有三个构造方法，如下：

    //只指定容量
    public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

    //指定容量和ReentrantLock是否公平
    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

    //将集合中的元素初始化队列的元素
    public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
        this(capacity, fair);

        final ReentrantLock lock = this.lock;
        lock.lock(); // Lock only for visibility, not mutual exclusion
        try {
            int i = 0;
            try {
                for (E e : c) {
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();
        }
    }

从上面的代码可以看到，构造方法主要使用容量对items数组完成初始化，fair参数用来构造一个公平的或不公平的ReentrantLock。对于不了解ReentrantLock的朋友，可以参考下面这篇文章： AbstractQueuedSynchronizer详解（一）——分析ReentrantLock源码。
另外一个构造方法就是使用集合中的元素初始化队列中的元素。

put(E e)方法

put(E e)方法在队列不满的情况下，将会将元素添加到队列尾部，如果队列已满，将会阻塞，直到队列中有剩余空间可以插入。该方法的实现如下：

 public void put(E e) throws InterruptedException {
        //检查元素是否为null，如果是，抛出NullPointerException
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lockInterruptibly();
        try {
            //如果队列已满，阻塞，等待队列成为不满状态
            while (count == items.length)
                notFull.await();
            //将元素入队
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

从上面代码可以看到几点：
1. ArrayBlockingQueue不允许元素为null
2. ArrayBlockingQueue在队列已满时将会调用notFull的await()方法释放锁并处于阻塞状态
3. 一旦ArrayBlockingQueue不为满的状态，就将元素入队

下面首先看一下enqueue方法。

enqueue(E e)方法

enqueue()方法用于将元素插入到队列中，由于有元素进入了队列，所以就通知了为空的Condition，释放了因队列为空而阻塞的线程。代码如下：

private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        notEmpty.signal();
    }

从上面的代码可以看到，底层的数组使用的循环插入的方式；当一旦插入一个元素后，将调用notEmpty.signal()。
当调用put()方法时，由于会首先对Lock加锁，然后再执行插入，所以当很多线程一起插入时，是线程安全的；而一旦进入lock块中，当当前队列已满时，该线程就会被阻塞，直到队列不再为满的时候，可以重新获取到锁执行插入；在插入之后，由于新加了一个元素，需要通知因为空而阻塞的线程，所以需要调用notEmpty的signal方法。

E take()方法

take()方法用于取走队头的元素，当队列为空时将会阻塞，直到队列中有元素可取走时将会被释放。其实现如下：

 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        //首先加锁
        lock.lockInterruptibly();
        try {
            //如果队列为空，阻塞
            while (count == 0)
                notEmpty.await();
            //队列不为空，调用dequeue()出队
            return dequeue();
        } finally {
            //释放锁
            lock.unlock();
        }
    }

从上面可以看到take()流程和put()流程类似，一旦获得了锁之后，如果队列为空，那么将阻塞；否则调用dequeue()出队一个元素。
下面看一下dequeue()方法。

dequeu()方法

private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        //取走数据
        E x = (E) items[takeIndex];
        //置为null，以助gc
        items[takeIndex] = null;
        //循环取
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        //通知因队列满而阻塞的线程
        notFull.signal();
        return x;
    }

代码中注释已经说明了dequeu的流程。
下面两个过程联合起来看，如果队列已满，那么调用put时，因为调用了notFull.await()，那么那个线程将会放弃锁进入到阻塞状态，这时一个线程取走了一个数据，调用了notFull.signal()，这时上一个线程有可能就被释放了然后重新获得了锁，调用了enqueue()方法将元素插入到队列中；如果队列为空，执行take()，那么由于调用了notEmpty.await()，该线程将会被阻塞，这时另一个线程执行了put()方法插入了一个元素，然后调用了notEmpty.signal()，这时取走线程被释放了重新获取了锁取走了数据。这基本就是ArrayBlockingQueue的阻塞实现原理。

总结

根据分析源码可知，ArrayBlockingQueue的并发阻塞是通过ReentrantLock和Condition来实现的，关于Condition可以参考下面这篇文章：java Condition源码分析
ArrayBlockingQueue内部只有一把锁，意味着同一时刻只有一个线程能进行入队或者出队的操作。 下一篇文章将介绍LinkedBlockingQueue。