JAVA阻塞队列之ArrayBlockingQueue

一、ArrayBlockingQueue简介

一个建立在数组之上被BlockingQueue绑定的阻塞队列。这个队列元素顺序是先进先出。队列的头部是在队列中待的时间最长的元素。队列的尾部是再队列中待的时间最短的元素。新的元素会被插入到队列尾部，并且队列从队列头部获取元素。

这是一个典型的绑定缓冲，在这个缓冲区中，有一个固定大小的数组持有生产者插入的数据，并且消费者会提取这些数据。一旦这个类被创建，那么这个数组的容量将不能再被改变。尝试使用put操作给一个满队列插入元素将导致这个操作被阻塞；尝试从空队列中取元素也会被阻塞。

这个类推荐了一个可选的公平策略来排序等待的生产者和消费者线程。默认的，这个顺序是不确定的。但是队列会使用公平的设置true来使线程按照先进先出顺序访问。通常公平性会减少吞吐量但是却减少了可变性以及避免了线程饥饿。

这个类和它的迭代器实现了所有可选的Collection按Iterator接口的方法。

二、源码解析

首先看一下ArrayBlockingQueue构造函数：

/**
 * Creates an {@code ArrayBlockingQueue} with the given (fixed)
 * capacity and the specified access policy.
 *
 * @param capacity the capacity of this queue
 * @param fair if {@code true} then queue accesses for threads blocked
 *        on insertion or removal, are processed in FIFO order;
 *        if {@code false} the access order is unspecified.
 * @throws IllegalArgumentException if {@code capacity < 1}
 */
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();
}

这个构造器中得参数fair大家注意到没有，正好是传给ReentrantLock的参数，而这个参数正好就是ReentrantLock决定是否为公平或者非公平队列的参数。再往下看到，这两个notEmpty和notFull参数实际上是Condition，而Condition可以把它看做一个阻塞信号，Condition的子类ConditionObject(是AbstractQueuedSynchronizer的内部类)拥有两个方法signal和signalAll方法，前一个方法是唤醒队列中得第一个线程，而signalAll是唤醒队列中得所有等待线程，但是只有一个等待的线程会被选择，这两个方法可以看做notify和notifyAll的变体。

下面我们重点看一下ArrayBlockingQueue特有的阻塞方法put()和take()

在put方法中，如果队列已经满了，则会调用notFull.await()方法来，直到队列有空位，才会调用insert方法插入元素，insert方法会调用notEmpty.signal()来唤醒等待线程。源代码如下：

/**
 * Inserts the specified element at the tail of this queue, waiting
 * for space to become available if the queue is full.
 *
 * @throws InterruptedException {@inheritDoc}
 * @throws NullPointerException {@inheritDoc}
 */
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();
    }
}

/**
 * Inserts element at current put position, advances, and signals.
 * Call only when holding lock.
 */
private void insert(E x) {
    items[putIndex] = x;
    putIndex = inc(putIndex);
    ++count;
    notEmpty.signal();
}

在take方法中，如果队列中没有元素，则会调用notEmpty.await()方法来阻塞队列，直到队列有元素，才会调用extract方法提取元素，extract方法会调用notFull.signal()来唤醒等待线程。源代码如下：

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

/**
 * Extracts element at current take position, advances, and signals.
 * Call only when holding lock.
 */
private E extract() {
    final Object[] items = this.items;
    E x = this.<E>cast(items[takeIndex]);
    items[takeIndex] = null;
    takeIndex = inc(takeIndex);
    --count;
    notFull.signal();
    return x;
}

三、总结

1.一旦创建，则容量不能再改动

2.这个类是线程安全的，并且迭代器也是线程安全，因为在实现的next和remove方法中都加了lock

3.这个类的put和take方法分别会在队列满了和队列空了之后被阻塞操作。

4.这个类提供了offer和poll方法来插入和提取元素，而不会在队列满了或者队列为空时阻塞操作。

5.这个队列的锁默认是不公平策略，即唤醒线程的顺序是不确定的。