队列：ArrayBlockingQueue源码解析

整体架构

数组阻塞队列的类注释信息如下，

1. 底层是有界数组(不能扩容)，容量一旦初始化，后续无法修改
2. 队列中元素是有顺序的，按照先入先出进行排序，从队伍插入数据，从队头拿出数据
3. 队列满时，放数据会被阻塞；队列空时，取数据会被阻塞

该类中几个重要的对象，

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

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

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

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

// 可重入的锁
final ReentrantLock lock;

// take的队列
private final Condition notEmpty;

// put的队列
private final Condition notFull;

其中takeIndex和putIndex较为关键，分布表示下次取数据和下次存数据时的索引位置。

该类的初始化方法如下，

public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = new Object[capacity];
    lock = new ReentrantLock(fair);
    // 队列不为空 Condition，在 put 成功时使用
    notEmpty = lock.newCondition();
    // 队列不满 Condition，在 take 成功时使用
    notFull =  lock.newCondition();
}

也可以指定初始化集合，不过一定要注意capacity的指定，

正确的capacity的指定应该为c.size()。

2.源码解析

新增数据—put方法

新增数据会按照putIndex的位置进行新增，源码如下，

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;
    // putIndex 为本次插入的位置
    items[putIndex] = x;
    // ++ putIndex 计算下次插入的位置
    // 如果下次插入的位置，正好等于队尾，下次插入就从 0 开始
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
    // 唤醒因为队列空，所以等待的线程
    notEmpty.signal();
}

新增是会遇到两种情况

1. 本次新增的位置不在队尾。如下图，本次新增位置是5，直接新增，下次新增位置是6；
   
2. 本次新增位置是队尾，则下一次的新增位置从头开始；
   
   此时会做判断，if (++putIndex == items.length)

取出数据—take方法

取出数据通过takeIndex变量，

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() {
    final Object[] items = this.items;
    // takeIndex 是上一次拿数据时计算好的
    E x = (E) items[takeIndex];
    // 帮助 gc
    items[takeIndex] = null;
    // ++ takeIndex 计算下次拿数据的位置
    // 如果正好等于队尾的话，下次就从 0 开始拿数据
    if (++takeIndex == items.length)
        takeIndex = 0;
    // 队列实际大小减 1
    count--;
    if (itrs != null)
        itrs.elementDequeued();
    // 唤醒被队列满所阻塞的线程
    notFull.signal();
    return x;
}

每次取数据的位置就是takeIndex的位置，在找到本次数据之后，改变量会加1，计算下一次拿数据时的索引。如果本次拿数据的位置是队尾，下一次拿数据的位置就要从头开始。

删除数据—removeAt方法

remove的情况相较于put和take稍显复杂，

void removeAt(final int removeIndex) {
    final Object[] items = this.items;
    // 情况1 如果删除位置正好等于下次要拿数据的位置
    if (removeIndex == takeIndex) {
        // 下次要拿数据的位置直接置空
        items[takeIndex] = null;
        // 要拿数据的位置往后移动一位
        if (++takeIndex == items.length)
            takeIndex = 0;
        // 当前数组的大小减一
        count--;
        if (itrs != null)
            itrs.elementDequeued();
    // 情况 2
    } else {
        final int putIndex = this.putIndex;
        for (int i = removeIndex;;) {
            // 找到要删除元素的下一个
            int next = i + 1;
            if (next == items.length)
                next = 0;
            // 下一个元素不是 putIndex
            if (next != putIndex) {
                // 下一个元素往前移动一位
                items[i] = items[next];
                i = next;
            // 下一个元素是 putIndex
            } else {
                // 删除元素
                items[i] = null;
                // 下次放元素时，应该从本次删除的元素放
                this.putIndex = i;
                break;
            }
        }
        count--;
        if (itrs != null)
            itrs.removedAt(removeIndex);
    }
    notFull.signal();
}

1. takeIndex == removeIndex的情况，
   
   删除takeIndex处的元素，将takeIndex的值加1。如果takeIndex是队尾，则删除后变为0。
2. takeIndex != removeIndex且removeIndex != putIndex的情况，
   
   删除removeIndex处的元素，将putIndex的值减一，队列中的元素向前移动一位。
3. takeIndex != removeIndex且removeIndex == putIndex的情况，
   
   直接删除removeIndex的元素，将putIndex的值减1。