JAVA无阻塞先进先出的队列_Java并发Concurrent包——ArrayBlockingQueue源码分析

ArrayBlockingQueue 是一个由数组支持的有界阻塞队列。此队列按 FIFO(先进先出)原则对元素进行排序。

BlockingQueue 接口实现的都是阻塞队列。而 ConcurrentLinkedQueue 是基于 CAS 和链表实现的无阻塞高性能队列。

ConcurrentLinkedQueue 的源码分析见 Java并发Concurrent包——ConcurrentLinkedQueue源码分析

这是一个典型的“有界缓存区”，固定大小的数组在其中保持生产者插入的元素和使用者提取的元素。一旦创建了这样的缓存区，就不能再增加其容量。试图向已满队列中放入元素会导致操作受阻塞；试图从空队列中提取元素将导致类似阻塞。

属性

// 底层对象数组

final Object[] items;

// 出队的下标

int takeIndex;

// 入队的下标

int putIndex;

// 元素个数

int count;

// 锁对象，控制所有访问

final ReentrantLock lock;

// 出队的condition

private final Condition notEmpty;

// 入队的condition

private final Condition notFull;

// 迭代器

transient Itrs itrs = null;

构造函数

列出一个最主要的构造函数来分析：

public ArrayBlockingQueue(int capacity, boolean fair) {

if (capacity <= 0)

throw new IllegalArgumentException();

// 初始化底层数组

this.items = new Object[capacity];

// 新建公平或非公平锁，和两个condition

lock = new ReentrantLock(fair);

notEmpty = lock.newCondition();

notFull = lock.newCondition();

}

重要方法

offer(E e)

public boolean offer(E e) {

// 判断对象不为null

checkNotNull(e);

// 锁对象

final ReentrantLock lock = this.lock;

// 加锁

lock.lock();

try {

if (count == items.length)

// 如果数组已经满了，不能再入队

return false;

else {

// 调用enqueue方法，下面分析

enqueue(e);

return true;

}

} finally {

lock.unlock();

}

}

enqueue(E x)

// 只在当前线程拥有锁的时候调用

private void enqueue(E x) {

final Object[] items = this.items;

// 在入队下标处放入新元素

items[putIndex] = x;

// 下标加1后，判断是否等于数组总长度，如果是将putIndex置为0

if (++putIndex == items.length)

putIndex = 0;

// 有效元素个数加1

count++;

// 唤醒其他基于此condition的线程

notEmpty.signal();

}

poll()

public E poll() {

final ReentrantLock lock = this.lock;

lock.lock();

try {

// 有效元素不为0就可以调用dequeue方法出列

return (count == 0) ? null : dequeue();

} finally {

lock.unlock();

}

}

dequeue()

// 只在当前线程拥有锁的时候调用

private E dequeue() {

final Object[] items = this.items;

@SuppressWarnings("unchecked")

// 保存出队下标处的元素

E x = (E) items[takeIndex];

// 将该下标处置为null

items[takeIndex] = null;

// 如果也走到尽头，从0开始

if (++takeIndex == items.length)

takeIndex = 0;

// 有效元素个数减1

count--;

//

if (itrs != null)

itrs.elementDequeued();

// 队列不再满，发信号给其他线程

notFull.signal();

// 返回出队的对象

return x;

}

take()

获取并移除此队列的头部，在元素变得可用之前一直等待(如果有必要)。

public E take() throws InterruptedException {

final ReentrantLock lock = this.lock;

lock.lockInterruptibly();

try {

// 如果可用元素为空，则等待notEmpty这个condition的信号

// 直到出现不为空时，进行出队操作

while (count == 0)

notEmpty.await();

return dequeue();

} finally {

lock.unlock();

}

}

put(E e)

将指定的元素插入此队列的尾部，如果该队列已满，则等待可用的空间。和 take 方法对应。

public void put(E e) throws InterruptedException {

checkNotNull(e);

final ReentrantLock lock = this.lock;

lock.lockInterruptibly();

try {

// 如果元素已满，则线程阻塞等待出现notFull的情况，才能入队

while (count == items.length)

notFull.await();

enqueue(e);

} finally {

lock.unlock();

}

}

该类的代码比较简单易懂。