介绍
ArrayBlockingQueue，一个由数组实现的有界阻塞队列。该队列采用 FIFO 的原则对元素进行排序添加的。
ArrayBlockingQueue 为有界且固定，其大小在构造时由构造函数来决定，确认之后就不能再改变了。
ArrayBlockingQueue 支持对等待的生产者线程和使用者线程进行排序的可选公平策略，但是在默认情况下不保证线程公平的访问，在构造时可以选择公平策略（fair = true）。公平性通常会降低吞吐量，但是减少了可变性和避免了“不平衡性”。
类的定义
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable
从类的定义中可以看出
- ArrayBlockingQueue是一个泛型类
- ArrayBlockingQueue继承了AbstractQueue类，AbstractQueue是一个抽象类（模板方法）
- ArrayBlockingQueue实现了BlockingQueue接口，表示一个阻塞队列
- ArrayBlockingQueue实现了java.io.Serializable，表示支持序列化
成员变量
//序列化版本号
private static final long serialVersionUID = -817911632652898426L;
//队列的元素
final Object[] items;
//下一个获取的元素下标，包括take, poll, peek or remove 方法
int takeIndex;
//下一个添加的元素下标，包括put, offer, or add方法
int putIndex;
//队列的元素个数
int count;
//锁
final ReentrantLock lock;
//等待获取元素的条件
private final Condition notEmpty;
//等待放入元素的条件
private final Condition notFull;
//迭代器，这是一个内部类
transient Itrs itrs = null;
从上面成员变量中可以看出，内部使用数组对象 items 来存储所有的数据；通过同一个 ReentrantLock 来同时控制添加数据线程和移除数据线程的并发访问，这个与 LinkedBlockingQueue 有很大区别(下面会进行分析)。
对于 notEmpty 条件对象是用于存放等待调用(此时队列中没有数据) take 方法的线程，这些线程会加入到 notEmpty 条件对象的等待队列(单链表)中，同时当队列中有数据后会通过 notEmpty 条件对象唤醒等待队列(链表)中等待的线程(链表中第一个non-null 且 status 为 Condition 的线程)去 take 数据。
对于 notFull 条件对象是用于存放等待调用(此时队列容量已满) put 方法的线程，这些线程会加入到 notFull 条件对象的等待队列(单链表)中，同时当队列中数据被消费后会通过 notFull 条件对象唤醒等待队列(链表)中等待的线程去 put 数据。takeIndex 表示的是下一个(take、poll、peek、remove)方法被调用时获取数组元素的索引，putIndex 表示的是下一个(put、offer、add)被调用时添加元素的索引。
数据出队、入队操作如下：
添加(阻塞添加)的实现分析
/**
* 在当前 put 位置插入数据，put 位置前进一位，
* 同时唤醒 notEmpty 条件对象等待队列(链表)中第一个可用线程去 take 数据。
* 当然这一系列动作只有该线程获取锁的时候才能进行，即只有获取锁的线程
* 才能执行 enqueue 操作。
*/
// 元素统一入队操作
private void enqueue(E x) {
// assert lock.getHoldCount() == 1;
// assert items[putIndex] == null;
final Object[] items = this.items;
items[putIndex] = x; // putIndex 位置添加数据
//putIndex 进行自增，当达到数组长度的时候，putIndex 重头再来，即设置为0
//为什么呢？下面会具体介绍
if (++putIndex == items.length)
putIndex = 0;
count++; //元素个数自增
notEmpty.signal(); //添加完数据后，说明数组中有数据了，所以可以唤醒 notEmpty 条件对象等待队列(链表)中第一个可用线程去 take 数据
}
// 添加数据，数组中元素已满时，直接返回 false。
public boolean offer(E e) {
checkNotNull(e);
final ReentrantLock lock = this.lock;
// 获取锁，保证线程安全
lock.lock();
try {
// 当数组元素个数已满时，直接返回false
if (count == items.length)
return false;
else {
// 执行入队操作，enqueue 方法在上面分析了
enqueue(e);
return true;
}
} finally {
// 释放锁，保证其他等待锁的线程可以获取到锁
// 为什么放到 finally (避免死锁)
lock.unlock();
}
}
// add 方法其实就是调用了 offer 方法来实现，
// 与 offer 方法的区别就是 offer 方法数组满，抛出 IllegalStateException 异常。
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
offer 方法和 add 方法实现很简单，大家只需要知道其区别就好了；这里着重讲一下 enqueue 方法里面留下的疑问，为什么当 putIndex 到了数组最后一个元素之后，是重头再来，设置为0；首先，你要想到 ArrayBlockingQueue 整个入队和出队操作都是线程安全的，而且 ArrayBlockingQueue 也是先进先出的队列；所以想一想，是不是数据入队后，从第一个数组位置上开始添加数据，依次往后入队；数据出队也是从数组第一个位置出队，出队后该位置数据为空，依次出队，然后这些位置数据都为空；所以只要 count 的个数没有达到数组长度时，虽然 putIndex 达到了数组长度，说明数组前面的位置上已经有数据出队了，所以添加元素，是不是就从头开始就行了(想明白了其实就很简单了，哈哈)。因为我们有一个 count 成员变量来记录元素的个数，当队列已满时，put 操作是会阻塞，add 操作会抛出异常，offer 操作会直接返回false；因此我们也不用担心数据会覆盖。这个 putIndex 和 takeIndex 达到数据长度后都会重新设置为0，重头开始再获取数据，整个过程就是一个无限循环的过程。 通过分析，我们发现有添加操作是不是有两种场景，一个是直接往后添加，一个是达到数据长度后，需要重头再来，
具体操作如下图：
下面看看阻塞添加方法(put)
/**
* 插入数据到队列尾部，如果队列已满，阻塞等待空间
*/
public void put(E e) throws InterruptedException {
checkNotNull(e);
final ReentrantLock lock = this.lock;
// 获取锁，期间线程可以打断，打断则不会添加
lock.lockInterruptibly();
try {
// 通过上述分析，我们通过 count 来判断数组中元素个数
while (count == items.length)
notFull.await(); // 元素已满，线程挂起，线程加入 notFull 条件对象等待队列(链表)中，等待被唤醒
enqueue(e); // 队列未满，直接执行入队操作
} finally {
lock.unlock();
}
}
通过源码分析，发现 offer, add 都是无阻塞添加方法，两者的具体区别在上面分析过了；而 put 方法确实是一个阻塞方法，当队列已满的时候，线程会挂起，然后将该线程加入到 notFull 条件对象的等待队列(链表)中；notFull 条件对象有两种情况，第一种是当队列已满，新来的 put 数据的线程会加入到其等待队列(链表)中，第二种情况是，当队列有空间时，会移除队列中的线程，移除成功同时唤醒 put 线程，加入到获取 lock 的等待队列(双链表)的尾部。
具体操作，如下图：
通过以上分析，ArrayBlockingQueue 的 offer、 add、 put 方法已经都详细分析完毕，希望大家可以对其有深入的了解。
提取(阻塞提取)的实现分析
提取即移除数组中的元素，下面我们具体来分析 ArrayBlockingQueue 的提取数组中元素的操作。
同上分析，我们首先从 dequeue 方法分析开始。
/**
* 提取 takeIndex 位置上的元素， 然后 takeIndex 前进一位，
* 同时唤醒 notFull 等待队列(链表)中的第一个可用线程去 put 数据。
* 这些操作都是在当前线程获取到锁的前提下进行的，
* 同时也说明了 dequeue 方法线程安全的。
*/
private E dequeue() {
// assert lock.getHoldCount() == 1;
// assert items[takeIndex] != null;
final Object[] items = this.items;
@SuppressWarnings("unchecked")
E x = (E) items[takeIndex]; // 提取 takeIndex位置上的数据
items[takeIndex] = null; // 同时清空数组在 takeIndex 位置上的数据
// takeIndex 向前前进一位，如果前进后位置超过了数组的长度，则将其设置为0；
// 为什么设置为0，理由在 putIndex 设置为0的时候介绍过了，原因是一样的。
if (++takeIndex == items.length)
takeIndex = 0;
count--; // 同时数组的元素个数进行减1
if (itrs != null)
itrs.elementDequeued(); // 同时更新迭代器中的元素，迭代器的具体分析会在下面单独整理
notFull.signal(); // 提取完数据后，说明数组中有空位，所以可以唤醒 notFull 条件对象的等待队列(链表)中的第一个可用线程去 put 数据
return x;
}
// 提取数据，数组中数据为空时，直接返回 null
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock(); // 加锁，前面也分析过，要执行 dequeue操作时，当前线程必须获取锁，保证线程安全
try {
return (count == 0) ? null : dequeue(); // 元素个数为0时，直接返回 null，不为0时，元素出队
} finally {
// 释放锁，在 finally 中释放可以避免死锁
lock.unlock();
}
}
上面 poll() 方法分析得很清晰了，内部通过 dequeue 删除队列头元素。下面分析下 peek 方法，与 poll 有较大的区别。
// 返回数组上第 i 个元素
final E itemAt(int i) {
return (E) items[i];
}
/**
* 通过代码可以看到，peek 是获取元素，而不是提取， 不会删除 takeIndex 位置上的数据。
* 内部通过 itemAt 方法实现，而不是 dequeue 方法。
*/
public E peek() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return itemAt(takeIndex); //当队列为空时，返回 null
} finally {
lock.unlock();
}
}
通过上述代码，可以看出 peek 和 poll 的区别，peek 是获取元素，不会删除 takeIndex 位置原有的数据，takeIndex 也不会向前前进一位。
下面来分析下阻塞提取 take 方法：
// 从队列头部提取数据，队列中没有元素则阻塞，阻塞期间线程可中断
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly(); //获取锁，期间线程可以打断，打断则不会提取
try {
// 元素为0时，当有线程提取元素，则将该线程加入到 notEmpty 条件对象的等待队列中，
// 直到当队列中有数据之后，会唤醒该线程去提取数据。
while (count == 0)
notEmpty.await();
return dequeue(); // 若有数据，直接调用 dequeue 提取数据
} finally {
lock.unlock();
}
}
其实分析完阻塞添加 put 方法后，再来看 take 方法，发现也是非常简单的，队列中有元素，直接提取，没有元素则线程阻塞(可中断的阻塞)，将该线程加入到 notEmpty 条件对象的等待队列中；等有新的 put 线程添加了数据，分析发现，会在 put 操作中唤醒 notEmpty 条件对象的等待队列中的 take 线程，去执行 take 操作。
具体操作如下图：
通过以上分析，我们把 poll、take 提取元素的方法分析了，也把 peek 获取元素的方法分析了，我们使用的时候，根据具体的场景使用具体的方法。
分析完提取方法后，我们来分析一下 ArrayBlockingQueue 中的删除元素的 remove 方法。
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) {
// removing front item; just advance
items[takeIndex] = null;
if (++takeIndex == items.length)
takeIndex = 0;
count--;
if (itrs != null)
itrs.elementDequeued();
} else {
// an "interior" remove
// slide over all others up through putIndex.
final int putIndex = this.putIndex;
for (int i = removeIndex;;) {
int next = i + 1;
if (next == items.length)
next = 0;
if (next != putIndex) {
items[i] = items[next];
i = next;
} else {
items[i] = null;
this.putIndex = i;
break;
}
}
count--;
if (itrs != null)
itrs.removedAt(removeIndex);
}
notFull.signal();
}
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();
}
}
总结来说
- ArrayBlockingQueue 的本质是一个Object数组
- ArrayBlockingQueue 通过ReentrantLock来控制同步操作
- ArrayBlockingQueue 有唤醒取元素（队列空了）和存元素（队列满了）的条件
- ArrayBlockingQueue 保存了操作的下标
构造方法
//传入容量
public ArrayBlockingQueue(int capacity) {
//转调下面的构造方法，false表示非公平锁
this(capacity, false);
}
//传入容量和锁的类型
public ArrayBlockingQueue(int capacity, boolean fair) {
//参数检查
if (capacity <= 0)
throw new IllegalArgumentException();
//初始化数组
this.items = new Object[capacity];
//初始化ReentrantLock锁和条件
lock = new ReentrantLock(fair);
notEmpty = lock.newCondition();
notFull = lock.newCondition();
}
//传入容量和锁的类型和集合数据
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;
//设置下一个要存放的元素下标
putIndex = (i == capacity) ? 0 : i;
} finally {
//解锁
lock.unlock();
}
}
-
可以清楚地看到 ArrayBlockingQueue 继承
java.util.AbstractQueue，实现java.util.concurrent.BlockingQueue接口。看过java.util包源码的同学应该都认识AbstractQueue，该类在java.util.Queue接口中扮演着非常重要的作用，该类提供了对queue 操作的骨干实现（具体内容移驾其源码）。 -
java.util.concurrent.BlockingQueue继承java.util.Queue接口，为阻塞队列的核心接口，提供了在多线程环境下的出列、入列操作。作为使用者，则不需要关心队列在什么时候阻塞线程，什么时候唤醒线程，所有一切均由 BlockingQueue 来完成。 -
ArrayBlockingQueue 内部使用可重入锁 ReentrantLock + Condition 来完成多线程环境的并发操作。
items变量，一个定长数组，维护 ArrayBlockingQueue 的元素。takeIndex变量，int，为 ArrayBlockingQueue 队首位置。putIndex变量，int，ArrayBlockingQueue 队尾位置。count变量，元素个数。
lock变量，ReentrantLock ，ArrayBlockingQueue 出列入列都必须获取该锁，两个步骤共用一个锁。notEmpty变量，非空，即出列条件。notFull变量，未满，即入列条件。
基本方法
add 方法
//添加元素到队尾
public boolean add(E e) {
//调用父类的方法
return super.add(e);
}
//父类的添加方法
public boolean add(E e) {
//实质是调用offer方法
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
#add(E e)方法，调用#offer(E e)方法，如果返回false，则直接抛出 IllegalStateException 异常。
offer 方法
//添加制定元素到队尾，如果队列满了直接返回false
public boolean offer(E e) {
checkNotNull(e);
//上锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
if (count == items.length)
//如果队列满了，直接返回false
return false;
else {
//队列还有空间，调用enqueue方法入队
enqueue(e);
return true;
}
} finally {
//释放锁资源
lock.unlock();
}
}
//添加制定元素到队尾，如果队列满了有超时时间的等待队列有元素出队
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)
//超时返回false
return false;
//带超时时间的条件等待
nanos = notFull.awaitNanos(nanos);
}
//未超时并且队列有空间，调用enqueue添加元素
enqueue(e);
return true;
} finally {
//释放锁资源
lock.unlock();
}
}
-
首先，检查是否为
null。 -
然后，获取 Lock 锁。获取锁成功后，如果队列已满则，直接返回 false 。
-
最后，调用
#enqueue(E e)方法，它为入列的核心方法，所有入列的方法最终都将调用该方法，在队列尾部插入元素。 -
相比
#offer(E e)方法，offer(E e, long timeout, TimeUnit unit) 增加了<1>处：- 若队列已满，调用
notFull的#awaitNanos(long nanos)方法，等待被通知（元素出列时，会调用notFull的#signal()方法，进行通知阻塞等待的入列线程）或者超时。 - 被通知后，再次检查队列是否非空。若非空，继续向下执行，否则继续等待被通知。
- 若队列已满，调用
enqueue 方法
//元素入队
private void enqueue(E x) {
//获取数组的副本
final Object[] items = this.items;
//把队尾元素设置为传入的元素
items[putIndex] = x;
//把队尾位置加1
if (++putIndex == items.length)
//如果队尾位置等于数组长度，队尾位置置为0，环形队列
putIndex = 0;
//元素数量加1
count++;
//唤醒等待队列有元素入队的线程
notEmpty.signal();
}
put 方法
//添加制定元素到队尾，如果队列满了一直等待队列有元素出队
public void put(E e) throws InterruptedException {
checkNotNull(e);
//上锁
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length)
//while循环，如果队列满了一直等待
notFull.await();
//队列还有空间，调用enqueue方法入队
enqueue(e);
} finally {
//释放锁资源
lock.unlock();
}
}
相比 #offer(E e) 方法，增加了 <1> 处：
- 若队列已满，调用
notFull的#await()方法，等待被通知（元素出列时，会调用notFull的#await()方法，进行通知阻塞等待的入列线程）。 - 被通知后，再次检查队列是否非空。若非空，继续向下执行，否则继续等待被通知。
poll 方法
//获取元素，如果队列没有元素直接返回null
public E poll() {
//上锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//如果队列有元素，调用dequeue获取元素，否则返回null
return (count == 0) ? null : dequeue();
} finally {
//释放锁资源
lock.unlock();
}
}
//获取元素，如果队列没有元素，有超时时间的等待队列有元素入队
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)
//超时返回null
return null;
//带超时时间的条件等待
nanos = notEmpty.awaitNanos(nanos);
}
//未超时并且队列有元素,调用dequeue方法获取元素
return dequeue();
} finally {
//释放锁资源
lock.unlock();
}
}
dequeue 方法
//出队
private E dequeue() {
//获取数组的副本
final Object[] items = this.items;
@SuppressWarnings("unchecked")
//获取队列起始元素
E x = (E) items[takeIndex];
//把队列起始位置置为null
items[takeIndex] = null;
//把队列起始位置加1
if (++takeIndex == items.length)
//如果队列起始位置等于数组长度，把队列起始位置设置为0
takeIndex = 0;
//元素数量减1
count--;
if (itrs != null)
//如果迭代器不为null，迭代器进行出队操作
itrs.elementDequeued();
//唤醒等待队列有元素出队的线程
notFull.signal();
//返回出队的元素
return x;
}
- 该方法主要是从列头（
takeIndex位置）取出元素，同时如果迭代器itrs不为null，则需要维护下该迭代器。最后，调用notFull的#signal()方法，唤醒阻塞在入列线程。
take 方法
//获取元素，如果队列没有元素，一直等待队列有元素入队
public E take() throws InterruptedException {
//上锁
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == 0)
//while循环，如果队列没有元素，一直带条件等待
notEmpty.await();
//调用dequeue方法获取元素
return dequeue();
} finally {
//释放锁资源
lock.unlock();
}
}
相比 #poll() 方法，增加了 <1> 处：
- 若队列已空，调用
notEmpty的#await()方法，等待被通知（元素入列时，会调用notEmpty的#signal()方法，进行通知阻塞等待的出列线程）。 - 被通知后，再次检查队列是否为空。若非空，继续向下执行，否则继续等待被通知。
peek 方法
//获取元素，元素不出队
public E peek() {
//上锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//调用itemAt方法获取元素
return itemAt(takeIndex); // null when queue is empty
} finally {
//释放锁资源
lock.unlock();
}
}
itemAt 方法
//返回指定位置的元素
final E itemAt(int i) {
return (E) items[i];
}
size 方法
//获取队列元素数量
public int size() {
//上锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//返回元素数量
return count;
} finally {
//释放锁资源
lock.unlock();
}
}
remainingCapacity 方法
//获取剩余容量
public int remainingCapacity() {
//上锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
//队列容量-元素容量=剩余容量
return items.length - count;
} finally {
//释放锁资源
lock.unlock();
}
}
remove 方法
//移除指定元素
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;
//while遍历查找
do {
if (o.equals(items[i])) {
//如果找到，调用removeAt方法移除元素
removeAt(i);
return true;
}
if (++i == items.length)
//如果达到数组的尾部，把i置为0.这里表示数组是循环队列，数组收尾相连
i = 0;
//从队首一直找到队尾
} while (i != putIndex);
}
//队列没有元素直接返回false
return false;
} finally {
//释放锁资源
lock.unlock();
}
}
removeAt 方法
//移除指定位置的元素
void removeAt(final int removeIndex) {
//获取队列的副本
final Object[] items = this.items;
if (removeIndex == takeIndex) {
//移除位置等于起始位置， 表示移除第一个元素
//把对应位置置为null
items[takeIndex] = null;
//起始位置加1
if (++takeIndex == items.length)
//如果起始位置加1等于数组长度，把起始位置置为0，环形队列
takeIndex = 0;
//元素数量减1
count--;
if (itrs != null)
//如果有迭代器，进行出队操作
itrs.elementDequeued();
} else {
//移除的元素不是第一个元素
//从删除位置开始，循环把后一个元素往前移动一位，并把最后一位置为null
//获取队尾下标副本
final int putIndex = this.putIndex;
//从移除位置开始for循环
for (int i = removeIndex;;) {
//获取下一个元素的下标
int next = i + 1;
if (next == items.length)
//判断如果达到数组尾部，把下标置为0
next = 0;
if (next != putIndex) {
//当前下标没有达到队尾
//使用后一个元素替换前一个元素
items[i] = items[next];
//把下标指向下一个元素继续遍历
i = next;
} else {
//到达队尾
//把最后一个元素置为null
items[i] = null;
//把队尾位置往前移动1位
this.putIndex = i;
//中断循环
break;
}
}
//元素数量减1
count--;
if (itrs != null)
//如果有迭代器，移除对应位置的元素
itrs.removedAt(removeIndex);
}
//唤醒等待队列有元素出队的线程
notFull.signal();
}
contains 方法
//查看队列是否包含指定元素
public boolean contains(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]))
//如果找到，返回true
return true;
if (++i == items.length)
//如果达到数组的尾部，把i置为0.这里表示数组是循环队列，数组收尾相连
i = 0;
//从队首一直找到队尾
} while (i != putIndex);
}
//队列没有元素直接返回false
return false;
} finally {
//释放锁资源
lock.unlock();
}
}
toArray 方法
//转换为数组，使用System.arraycopy拷贝队首到队尾的元素，拷贝数量为count
public Object[] toArray() {
Object[] a;
final ReentrantLock lock = this.lock;
lock.lock();
try {
final int count = this.count;
a = new Object[count];
int n = items.length - takeIndex;
if (count <= n)
System.arraycopy(items, takeIndex, a, 0, count);
else {
System.arraycopy(items, takeIndex, a, 0, n);
System.arraycopy(items, 0, a, n, count - n);
}
} finally {
lock.unlock();
}
return a;
}
//队列元素添加到指定数组，跟上面的方法一样
public <T> T[] toArray(T[] a) {
final Object[] items = this.items;
final ReentrantLock lock = this.lock;
lock.lock();
try {
final int count = this.count;
final int len = a.length;
if (len < count)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), count);
int n = items.length - takeIndex;
if (count <= n)
//前后有空位
System.arraycopy(items, takeIndex, a, 0, count);
else {
//中间有空位
System.arraycopy(items, takeIndex, a, 0, n);
System.arraycopy(items, 0, a, n, count - n);
}
if (len > count)
a[count] = null;
} finally {
lock.unlock();
}
return a;
}
clear 方法
//清空所有元素
public void clear() {
//获取队列副本
final Object[] items = this.items;
//上锁
final ReentrantLock lock = this.lock;
lock.lock();
try {
int k = count;
if (k > 0) {
//如果有元素
//循环置为null
final int putIndex = this.putIndex;
int i = takeIndex;
do {
items[i] = null;
if (++i == items.length)
i = 0;
} while (i != putIndex);
takeIndex = putIndex;
//元素数量置为0
count = 0;
if (itrs != null)
itrs.queueIsEmpty();
for (; k > 0 && lock.hasWaiters(notFull); k--)
//唤醒等待队列有元素出队的线程
notFull.signal();
}
} finally {
//释放锁资源
lock.unlock();
}
}
drainTo 方法
//移除并且添加到指定集合
public int drainTo(Collection<? super E> c) {
//调用下面的方法
return drainTo(c, Integer.MAX_VALUE);
}
//移除指定数量的元素添加到指定集合
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循环处理逻辑
while (i < n) {
//获取元素
E x = (E) items[take];
//把获取的元素添加到指定集合
c.add(x);
//清除队列的引用
items[take] = null;
if (++take == items.length)
//到队尾了把下标置为0， 环形队列
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)
//迭代器置为null
itrs.queueIsEmpty();
else if (i > take)
//迭代器移除对应元素
itrs.takeIndexWrapped();
}
for (; i > 0 && lock.hasWaiters(notFull); i--)
//唤醒等待队列有元素出队的线程
notFull.signal();
}
}
} finally {
//释放锁资源
lock.unlock();
}
}
iterator 方法
//获取迭代器
public Iterator<E> iterator() {
//Itr是内部类，可以获取外部类所有的信息
return new Itr();
}
作者：我很丑
链接：https://juejin.cn/post/6844904095220760584
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
