19-ArrayBlockingQueue 源码解析（队列）

注：源码系列文章主要是对某付费专栏的总结记录。如有侵权，请联系删除。

1 整体架构

1.1 类注释

1. 有界的阻塞数组，容量一旦创建，后续大小无法修改；
2. 元素时有顺序的，按照先入先出进行排序，从队尾插入数据，从队头拿数据；
3. 队列满时，往队列中 put 数据会被阻塞，队列为空，往队列中拿数据也会被阻塞。

从类注释上可以看出 ArrayBlockingQueue 和一般的数组结构的类不太一样，是不能够动态扩容的，如果队列满了或者空时，take 和 put 都会被阻塞。

1.2 数据结构

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

    // 队列数据存放在 Object 的数组里面
    // 数组大小必须在初始化的时候手动设置大小，没有默认大小
    final Object[] items;

    // 下次拿数据时候的索引位置
    int takeIndex;

    // 下次放数据时候的索引位置
    int putIndex;

    // 当前已有元素的大小
    int count;

   	// 可重入锁 
    final ReentrantLock lock;

    // take 锁
    private final Condition notEmpty;

    // put 锁
    private final Condition notFull;
}

两个关键的字段： takeIndex 和 putIndex，分别表示下次拿数据和放数据的索引位置。所以说在新增数据和拿数据时，都无需计算，就能知道应该新增到什么位置，应该从什么位置拿数据。

2 初始化

初始化时，有两个重要的参数：数组的大小、是否是公平锁。源码：

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

从源码中我们可以看出，第二个参数是否公平，主要用于读写锁是否公平，如果是公平锁，那么在锁竞争时，就会按照先来先到的顺序，如果是非公平锁，锁竞争是随机的。

对于锁公平和非公平，举个例子：比如说现在队列是满的，还有很多线程执行 put 操作，必然会有很多线程阻塞等待，当有其它线程执行 take 时，会唤醒等待的线程，如果是公平锁，会按照阻塞等待的先后顺序，依次唤醒阻塞的线程，如果是非公平锁，会随机唤醒沉睡的线程。

所以说队列满并且很多线程执行 put 操作时，如果是公平锁，数组元素新增的顺序就是阻塞线程被释放的先后顺序，是有顺序的；而非公平锁，由于阻塞线程被释放的顺序是随机的，所以元素插入到数组的顺序也就不会按照插入的顺序了。

队列空时，也是一样的道理。

ArrayBlockingQueue 通过锁的公平和非公平，轻松实现了数组元素的插入顺序的问题。如果我们要实现这个功能，要如何做呢？会想到利用锁的功能么？其实这种思想之前多次提到，当我们需要完成一件事情时，首先看看已有的 API 能不能满足，如果可以的话，通过继承和组合的方式实现，ArrayBlockingQueue 就是组合了锁的功能。

初始化时，如果给定了原始数据的话，一定要注意原始数据的大小一定要小于队列的容量，否则会抛异常，如：

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;
        // 如果插入的位置，正好是队尾了，下次需要从 0 开始插入
        putIndex = (i == capacity) ? 0 : i;
    } finally {
        lock.unlock();
    }
}

3 新增数据

// 新增数据
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();
    }
}

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1; // 同一时刻只能一个线程进行操作此方法
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    // 插入元素
    items[putIndex] = x;
    // ++putIndex 计算下次插入的位置
    // 如果下次插入的位置正好等于队尾，下次插入就从 0 开始
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    // 唤醒其它因为队列为空导致的等待线程
    notEmpty.signal();
}

从源码中我们可以看出，其实新增就两种情况：

1. 新增之后下次新增的位置非队尾，直接新增；
2. 新增之后下次新增的位置为队尾，那么下次新增时就要从头开始了。

4 拿数据

拿数据都是从队头开始拿数据，源码：

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lockInterruptibly();
    try {
    	// 如果队列为空则等待
        while (count == 0)
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    // takeIndex 是本次拿数据的位置，是上一次拿数据时计算好的
    E x = (E) items[takeIndex];
    // help gc
    items[takeIndex] = null;
    // takeindex + 1: 下次要拿的位置
    // 如果下次要拿的位置正好等于队尾时，下次就从 0 开始拿数据
    if (++takeIndex == items.length)
        takeIndex = 0;
    // 队列大小减一
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    // 唤醒因为队列满 put 时阻塞的线程
    notFull.signal();
    return x;
}

从源码中可以看出，每次拿数据的位置就是 takeIndex 的位置，在找到本次该拿的数据之后，会把 takeIndex 加 1，计算下次拿数据时的索引位置，如果本次拿的数据已经是队尾数据了，那么下次拿数据的位置就要从头开始，也就是 takeIndex = 0 了。

5 删除数据

public boolean remove(Object o) {
    if (o == null) return false;
    final Object[] items = this.items;
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        if (count > 0) {
            final int putIndex = this.putIndex;
            int i = takeIndex;
            do {
            	// 找到要删除元素的位置
                if (o.equals(items[i])) {
                    removeAt(i);
                    return true;
                }
                if (++i == items.length)
                    i = 0;
            } while (i != putIndex);
        }
        return false;
    } finally {
        lock.unlock();
    }
}

void removeAt(final int removeIndex) {
    // assert lock.getHoldCount() == 1;
    // assert items[removeIndex] != null;
    // assert removeIndex >= 0 && removeIndex < items.length;
    final Object[] items = this.items;
    // 如果要删除的位置正好是下次要拿的位置
    if (removeIndex == takeIndex) {
        // 则直接将当前要删除位置的数据置位null
        items[takeIndex] = null;
        // takeIndex + 1: 下次要拿的位置
        // 如果下次要拿的位置等于队尾，则置位0，下次从头拿
        if (++takeIndex == items.length)
            takeIndex = 0;
        // 队列大小 -1
        count--;
        if (itrs != null)
            itrs.elementDequeued();
    } else {
        final int putIndex = this.putIndex;
        // 从要删除的位置开始循环
        for (int i = removeIndex;;) {
        	// 要删除元素的下一个元素
            int next = i + 1;
            // 当要删除的下一个元素索引等于队列数据长度时，表示当前要删除的数据为队尾
            // 而队尾的下一个元素就是队头 0
            if (next == items.length)
                next = 0;

            // 如果要删除元素的下一个位置不等于 putIndex
            // 则将当前要删除位置后面的值向前移动一位（也就是 items[i] = items[next]）
            // 同时将 i 赋值为 next
            if (next != putIndex) {
                items[i] = items[next];
                i = next;
            } 
            // 反之如果要删除元素的下一个位置等于 putIndex
            // 则将当前要删除位置 i 置位 null，并将 putIndex 赋值为当前位置 i
            else {
                items[i] = null;
                this.putIndex = i;
                break;
            }
        }
        // 队列大小 -1
        count--;
        if (itrs != null)
            itrs.removedAt(removeIndex);
    }
    // 通知 put 时因为队列满而阻塞等待的线程
    notFull.signal();
}

删除数据的情况比较复杂，总结起来就两种情况。

第一种情况是 takeIndex == removeIndex，示意图：

第二种情况又分为两种：

1. 如果 removeIndex + 1 != putIndex 的话，就把下一个元素往前移动一位，示意图：

2. 如果 removeIndex + 1 == putIndex 的话，就把 putIndex 的值修改成要 removeIndex，示意图：

6 总结

ArrayBlockingQueue 底层是有界的数组，整体来说，和其它队列差不多，需要注意的是，当 takeIndex、putIndex 到队尾的时候，都会从 0 开始循环，这点是比较特殊的，在我们学习源码时，需要特别注意。

------------------------------------- END -------------------------------------