java源码阅读ArrayBlockingQueue

1类签名与简介

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable

一个有限的阻塞队列由数组支持。 这个队列排列元素FIFO（先进先出）。新元素插入队列的尾部，队列检索操作获取队列头部的元素。

ArrayBlockingQueue是线程安全的，其内部通过“互斥锁”（Lock）保护竞争资源，实现了多线程对竞争资源的互斥访问。

ArrayBlockingQueue的容量是固定的，确定之后无法更改。该实现既包含了一组非阻塞的操作的API，也包括了一组阻塞操作的API。

阻塞情况有如下两种：（1）当队列为null时，取操作会阻塞；（2）当队列为满时，插入操作会被阻塞。

ArrayBlockingQueue是并发包中的类，可以用来实现经典的“生产者/消费者”模型。

2重要属性

//items数组存储队列中的元素
final Object[] items;

//下一个取元素的索引（take, poll, peek or remove ）
int takeIndex;

//下一个插入元素应该的索引（put, offer, or add）
int putIndex;

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

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

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

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

takeIndex表示下一个待取元素的索引，对于队列来说就是队头，相应的putIndex指向队尾。lock是ArrayBlockingQueue类的主锁，该类的主要方法都要加上此锁。

notEmpty和notFull实现了队列的阻塞，当为队列为null时，再取元素就会调用notEmpty.await()进入阻塞状态，当入队时肯定不为空，就会调用notEmpty.signal()唤醒阻塞的线程继续执行。同理notFull就不多介绍，对Lock锁与Condition 不熟悉的多线程基本知识了解一下。

3 基本操作（入队/出队）

（1）入队enqueue

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();
    }

首先，在队尾也就是putIndex指向的位置插入新元素；然后，putIndex增1，若此时putIndex等于items.length（超过了数组的最后一位items.length-1），putIndex循环到数组的第一位。同理面的takeIndex也有次操作，所以该队列是由循环数组实现的，每次插入队尾后移1位，每次取出队头向后移1位。图就不画，自行脑补。然后计数count++；最后随机唤醒1个由notEmpty.await阻塞的线程（若有的话），因为有元素入队了，此时队列肯定不为null了。

（2）出队dequeue

private E dequeue() {
        // assert lock.getHoldCount() == 1;
        // assert items[takeIndex] != null;
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();
        return x;
    }

删除队头元素。

4常用方法

（1）添加/入队（add、offer、put）

add方法如下

public boolean add(E e) {
        return super.add(e);
    }

//父类AbstractQueue中的add
public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }

ArrayBlockingQueue的add调用了父类AbstractQueue的add，add方法调用offer方法进行插入，offer返回true则add成功，offer返回false也就是插入失败会抛出异常。ArrayBlockingQueue实现了自己的offer，所以此处虽然调用父类的add，但是继承过来的add会调用自己的offer（多态）。

offer代码如下

public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }

这里offer调用enqueue进行入队操作，当队列为满时不会阻塞，而是直接返回false。所以与add相比，offer一个明显的不同是，插入失败时不会报异常。但是add与这里的offer都不是阻塞方法。offer也提供了一个阻塞的重载版本

public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {

        checkNotNull(e);
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length) {
                if (nanos <= 0)
                    return false;
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(e);
            return true;
        } finally {
            lock.unlock();
        }
    }

队列若满，则线程会阻塞timeout长的时间，超时唤醒后会继续判断队列是否为满。还有一个添加的阻塞方法就是put，对于阻塞似乎put方法更加常用。

public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

与上面的offer类似，不同的是没有阻塞时间，需要被notFull Condition来唤醒。

（2）删除/出队（poll、take）

poll方法如下

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

这里的poll提供了一个非阻塞的出队操作。当队列为空时，返回null，否则出队并返回出队的元素。

当然，与offer类似，poll还有一个阻塞的重载版本。

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 dequeue();
        } finally {
            lock.unlock();
        }
    }

ArrayBlockingQueue还提供了一个专门的出队阻塞方法take

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

当队列为null时，调用 notEmpty.await()使当前线程进入阻塞状态。下一次入队时会有notEmpty.signal()唤醒阻塞线程，这个唤醒只能唤醒一个，而且是随机的。

（3）查看队头元素peek

public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return itemAt(takeIndex); // null when queue is empty
        } finally {
            lock.unlock();
        }
    }

返回队头元素，不删除。

（4）其他

由于ArrayBlockingQueue是由数组实现的，除了出队（删除队头元素），当然也可以删除任意位置的元素，所以此类对于删除操作还提供了如下方法

remove(Object o) //查找队列，若存在元素o则删除

removeAt(final int removeIndex) //删除指定位置的元素

ArrayBlockingQueue重写了toString方法，将队列中所有元素用[]括起来，然后元素之间用逗号加空格分开。详细自行阅读源码。

drainTo

//将队列中的所有元素放到集合c中
public int drainTo(Collection<? super E> c) {
        return drainTo(c, Integer.MAX_VALUE);
    }

//将队列中的所有元素放到集合c中   
public int drainTo(Collection<? super E> c, int maxElements) {
        checkNotNull(c);
        if (c == this)
            throw new IllegalArgumentException();
        if (maxElements <= 0)
            return 0;
        final Object[] items = this.items;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            int n = Math.min(maxElements, count);
            int take = takeIndex;
            int i = 0;
            try {
                while (i < n) {
                    @SuppressWarnings("unchecked")
                    E x = (E) items[take];
                    c.add(x);
                    items[take] = null;
                    if (++take == items.length)
                        take = 0;
                    i++;
                }
                return n;
            } finally {
                // Restore invariants even if c.add() threw
                if (i > 0) {
                    count -= i;
                    takeIndex = take;
                    if (itrs != null) {
                        if (count == 0)
                            itrs.queueIsEmpty();
                        else if (i > take)
                            itrs.takeIndexWrapped();
                    }
                    for (; i > 0 && lock.hasWaiters(notFull); i--)
                        notFull.signal();
                }
            }
        } finally {
            lock.unlock();
        }
    }

完