ArrayBlockingQueue源码分析-CSDN博客

本文链接：https://blog.csdn.net/weixin_39035120/article/details/104271677

ArrayBlockingQueue是阻塞队列，FIFO先进先出。

阻塞队列api：

插入：

add(e):

添加元素到队列中，如果队列满了，继续插入元素会报错，IllegalStateException。

offer(e):

添加元素到队列，同时会返回元素是否插入成功的状态，如果成功则返回 true

offer(e,time,unit):

当阻塞队列满了以后继续添加元素，生产者线程会被阻塞指定时间，如果超时，则线程直接退出

put(e):

当阻塞队列满了以后，生产者继续通过 put添加元素，队列会一直阻塞生产者线程，知道队列可用

取出：

remove():

当队列为空时，调用 remove 会返回 false，如果元素移除成功，则返回 true

poll();

当队列中存在元素，则从队列中取出一个元素，如果队列为空，则直接返回 null

poll(time,unit):

带超时机制的获取数据，如果队列为空，则会等待指定的时间再去获取元素返回

take():

基于阻塞的方式获取队列中的元素，如果队列为空，则 take 方法会一直阻塞，直到队列中有新的数据可以消费

源码解读：

构造方法：

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

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

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

public ArrayBlockingQueue(int capacity) {
    this(capacity, false);
}

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

初始化一个数组大小，默认是非公平锁。Condition相当于wait和notify，需要被ReentrantLock包裹。

先看一下add(e)方法：

public boolean add(E e) {
    return super.add(e);
}
public boolean add(E e) {
    if (offer(e))
        return true;
    else
        throw new IllegalStateException("Queue full");
}

源码清晰可见，add实际调用的是offer方法，如果offer失败，则抛出异常。

接下来，再看offer(e)方法

public boolean offer(E e) {
    checkNotNull(e);
    //加锁，保证原子性
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
         //count是记录元素个数，如果数组已满，则添加失败
        if (count == items.length)
            return false;
        else {
            //未满
            enqueue(e);
            return true;
        }
    } finally {
        lock.unlock();
    }
}

/** items index for next put, offer, or add */
int putIndex;

/**
* Inserts element at current put position, advances, and signals.
* Call only when holding lock.
*/
private void enqueue(E x) {
    final Object[] items = this.items;
    items[putIndex] = x;
    if (++putIndex == items.length)
        putIndex = 0;
    //增加元素计数
    count++;
    //通知队列不是为空，唤醒从队列获取元素线程
    notEmpty.signal();
}

putIndex就是元素存放的下标，如果队列满了，putIndex重新置为0.

最后看看put(e)方法：

put和add的区别就是，如果队列满了，put会阻塞。

/**
* Inserts the specified element at the tail of this queue, waiting
* for space to become available if the queue is full.
*/
public void put(E e) throws InterruptedException {
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    //和 lock 的区别是，这个方法优先允许在等待时由其他线程调用等待线程的 interrupt 方法来中断等待直接返回。而 lock方法是尝试获得锁成功后才响应中断
    lock.lockInterruptibly();
    try {
        while (count == items.length)
            //如果队列满了，则被条件对象挂起到等待队列里，当其他消费线程消费元素后，会notFull.signal()会唤醒生产线程。
            notFull.await();

        //同上
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

分析完插入，再分析移除方法。

先看take()方法：

take 方法是一种阻塞获取队列中元素的方法

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0)
            //当队列为空时候，被条件对象挂起到等待队列。当生产者插入元素，则notEmpty.sinal()唤醒消费线程。
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    final Object[] items = this.items;
    //获取takeIndex下标的元素
    E x = (E) items[takeIndex];
    //删除该元素
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        //如果takeIndex等于数组长度，改为0
        takeIndex = 0;
    count--;
    if (itrs != null)
        //更新迭代器中数据
        itrs.elementDequeued();
    //唤醒生产线程进行添加元素
    notFull.signal();
    return x;
}

这里分析下putIndex和takeIndex: