ArrayBlockingQueue
ArrayBlockingQueue 能解决什么问题？什么时候使用 ArrayBlockingQueue?
1）ArrayBlockingQueue 是底层由数组支持的有界阻塞队列，队列按照 FIFO 顺序对元素进行排序，读取元素从头部开始，写入元素追加到队列尾部。
2）当容量超出限制时，put 写入操作将被阻塞；当队列为空时，take 读取操作将被阻塞。
3）offer 操作支持 fast-fail 写入和超时写入，poll 支持 fast-fail 读取和超时读取。
4）ArrayBlockingQueue 支持对等待的生产者线程和消费者线程进行排序的可选公平策略，默认情况下是非公平的，公平模式下会降低其吞吐量。
5）ArrayBlockingQueue 使用 ReentrantLock 来保证线程安全。
如何使用 ArrayBlockingQueue?
1）生成者消费者并发读写的场景下，并且生产者和消费者基本平衡。
使用 ArrayBlockingQueue 有什么风险？
1）读写操作使用相同的互斥锁，不支持并发读写，相对于 LinkedBlockingQueue 而言性能不是特别高。
2）消费者和生产者不平衡时，高并发读写会阻塞操作线程导致大量线程等待，浪费资源。
ArrayBlockingQueue 核心操作的实现原理？
/** 底层存储元素的对象数组 */
final Object[] items;
/** 下一次 take, poll, peek or remove 操作的目标元素索引 */
int takeIndex;
/** 下一次 put, offer, or add 操作的目标元素索引*/
int putIndex;
/** 队列中的已有元素个数 */
int count;
/*
* Concurrency control uses the classic two-condition algorithm
* found in any textbook.
*/
/** 保证线程安全访问的可重入互斥锁 */
final ReentrantLock lock;
/** 读取元素时，队列为空，则在该条件上阻塞 */
private final Condition notEmpty;
/** 写入元素时，队列已满，则在该条件上阻塞 */
private final Condition notFull;
/**
* 创建最大容量为 capacity 的非公平有界阻塞队列。
*/
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
/**
* 1）fair=true，创建最大容量为 capacity 的公平有界阻塞队列。
* 2）fair=true，创建最大容量为 capacity 的非公平有界阻塞队列。
*/
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();
}
- 写入元素：获取互斥锁，进入条件队列后释放互斥锁，节点被转移到同步队列中并获取互斥锁，put 操作完毕释放互斥锁。
/**
* 将元素添加到队列尾部，如果队列已满，则阻塞当前线程。
* 可响应线程中断
*/
@Override
public void put(E e) throws InterruptedException {
Objects.requireNonNull(e);
// 读取互斥锁
final ReentrantLock lock = this.lock;
// 可中断地获取互斥锁
lock.lockInterruptibly();
try {
// 如果队列已满
while (count == items.length) {
/**
* 则将当前线程加入非满的条件队列，并阻塞等待唤醒，
* 当前线程被唤醒后会再次尝试将目标元素加入到队列中，可以被重复阻塞。
*/
notFull.await();
}
// 将元素添加到队列尾部
enqueue(e);
} finally {
// 释放锁
lock.unlock();
}
}
AbstractQueuedSynchronizer#
/**
* 当前线程在指定条件上阻塞等待
*/
public final void await() throws InterruptedException {
// 线程被设置了中断标识
if (Thread.interrupted()) {
throw new InterruptedException();
}
// 创建一个新的节点并将其加入到条件队列尾部
final Node node = addConditionWaiter();
// 尝试释放互斥锁，并返回同步状态
final int savedState = fullyRelease(node);
int interruptMode = 0;
// 如果新建节点在条件队列中
while (!isOnSyncQueue(node)) {
// 阻塞当前线程，等待被 signal 唤醒或被其他线程中断
LockSupport.park(this);
// 读取线程的中断状态，如果未被中断，则退出循环
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) {
break;
}
}
/**
* 1）在独占、线程不可中断的模式下获取锁，如果线程被中断
* && 是在被唤醒后中断，则更新中断模式。
*/
if (acquireQueued(node, savedState) && interruptMode != ConditionObject.THROW_IE) {
interruptMode = ConditionObject.REINTERRUPT;
}
// 当前节点存在后置节点
if (node.nextWaiter != null) {
// 踢除无效节点
unlinkCancelledWaiters();
}
// 如果中断模式不是 0
if (interruptMode != 0) {
reportInterruptAfterWait(interruptMode);
}
}
private Node addConditionWaiter() {
// 互斥锁没有被当前线程持有
if (!isHeldExclusively()) {
// 则抛出 IllegalMonitorStateException 异常
throw new IllegalMonitorStateException();
}
// 读取最后一个等待节点
Node t = lastWaiter;
// 条件队列中的最后一个节点已经被取消
if (t != null && t.waitStatus != Node.CONDITION) {
// 踢除所有被取消的节点
unlinkCancelledWaiters();
// 重新读取条件队列尾节点
t = lastWaiter;
}
// 创建一个条件节点，waitStatus=-2
final Node node = new Node(Node.CONDITION);
// 尾节点为空，表示当前节点是第一个有效的节点
if (t == null) {
// 设置头节点
firstWaiter = node;
} else {
// 更新旧尾节点的后置节点，即将当前节点链接到条件队列尾部
t.nextWaiter = node;
}
// 更新尾节点
lastWaiter = node;
return node;
}
private void unlinkCancelledWaiters() {
// 读取条件队列头节点
Node t = firstWaiter;
Node trail = null;
while (t != null) {
// 读取后置节点
final Node next = t.nextWaiter;
// 当前节点的同步状态不是 Node.CONDITION，则需要踢除
if (t.waitStatus != Node.CONDITION) {
t.nextWaiter = null;
// 还没有有效的节点
if (trail == null) {
// 更新头节点
firstWaiter = next;
} else {
// 更新最近一个有效节点的 nextWaiter
trail.nextWaiter = next;
}
// 已经遍历到最后一个节点，并且该节点被取消
if (next == null) {
// 更新尾节点为最近一个有效节点
lastWaiter = trail;
}
} else {
// 写入最近一个有效节点
trail = t;
}
// 递归处理下一个节点
t = next;
}
}
/**
* 释放互斥锁
*/
final int fullyRelease(Node node) {
try {
// 读取同步状态
final int savedState = getState();
// 在独占模式下释放锁
if (release(savedState)) {
return savedState;
}
throw new IllegalMonitorStateException();
} catch (final Throwable t) {
node.waitStatus = Node.CANCELLED;
throw t;
}
}
/**
* 在独占模式下释放锁
*/
public final boolean release(int arg) {
// 尝试释放锁
if (tryRelease(arg)) {
// 读取头节点
final Node h = head;
// 头结点的同步状态不为 0，则唤醒其后置节点
if (h != null && h.waitStatus != 0) {
// 唤醒目标节点的后继节点
unparkSuccessor(h);
}
return true;
}
return false;
}
/**
* 形参节点是否在条件队列中
*/
final boolean isOnSyncQueue(Node node) {
// 节点等待状态为 Node.CONDITION，或节点无前置节点，都说明其在同步队列中
if (node.waitStatus == Node.CONDITION || node.prev == null) {
return false;
}
// 节点的 next 不为 null，则其在条件队列中
if (node.next != null) {
return true;
}
// 从尾部开始查找节点
return findNodeFromTail(node);
}
/**
* 从尾部向前查找形参节点，如果其在条件队列中，则返回 true
*/
private boolean findNodeFromTail(Node node) {
for (Node p = tail;;) {
// 当前节点就是目标节点
if (p == node) {
return true;
}
// 已经无前置节点
if (p == null) {
return false;
}
// 迭代前一个节点
p = p.prev;
}
}
/**
* 检查线程中断状态
* 1）ConditionObject.THROW_IE 线程在被唤醒前，被其他线程中断
* 2）ConditionObject.REINTERRUPT 线程在被唤醒后，被其他线程中断
* 3）0 线程未被中断
*/
private int checkInterruptWhileWaiting(Node node) {
return Thread.interrupted() ?
transferAfterCancelledWait(node) ? ConditionObject.THROW_IE : ConditionObject.REINTERRUPT :
0;
}
/**
* 等待条件已经取消，则尝试将当前节点转移到同步队列
*/
final boolean transferAfterCancelledWait(Node node) {
// 更新同步状态为 0
if (node.compareAndSetWaitStatus(Node.CONDITION, 0)) {
// 将当前节点加入到同步队列尾部，等待获取锁
enq(node);
return true;
}
/**
* 在节点被转移到同步队列时，线程被唤醒，则自旋等待其完全进入同步队列为止
*/
while (!isOnSyncQueue(node)) {
Thread.yield();
}
return false;
}
/**
* 将节点加入到同步队列尾部
*/
private Node enq(Node node) {
for (;;) {
final Node oldTail = tail;
if (oldTail != null) {
node.setPrevRelaxed(oldTail);
if (compareAndSetTail(oldTail, node)) {
oldTail.next = node;
return oldTail;
}
} else {
initializeSyncQueue();
}
}
}
/**
* 在独占、线程不可中断的模式下获取锁，当前线程已经在同步队列中。
*/
final boolean acquireQueued(final Node node, int arg) {
boolean interrupted = false;
try {
for (;;) {
// 读取当前节点的前置节点
final Node p = node.predecessor();
// 如果前置节点是 head，则尝试获取锁
if (p == head && tryAcquire(arg)) {
// 获取成功，则设置当前节点为 head
setHead(node);
p.next = null; // help GC
// 返回线程中断标识
return interrupted;
}
// 当前线程是否需要被阻塞
if (AbstractQueuedSynchronizer.shouldParkAfterFailedAcquire(p, node)) {
// 阻塞当前线程，并等待唤醒，唤醒后返回其中断状态
interrupted |= parkAndCheckInterrupt();
}
}
// 线程运行过程中出现异常
} catch (final Throwable t) {
// 取消当前节点
cancelAcquire(node);
// 如果线程被设置中断标识
if (interrupted) {
// 则线程自我中断
AbstractQueuedSynchronizer.selfInterrupt();
}
throw t;
}
}
private void reportInterruptAfterWait(int interruptMode)
throws InterruptedException {
// 1）线程在被唤醒前，被其他线程设置了中断标识
if (interruptMode == ConditionObject.THROW_IE) {
// 则抛出 InterruptedException 异常
throw new InterruptedException();
// 2）线程在被唤醒后，被其他线程设置了中断标识
} else if (interruptMode == ConditionObject.REINTERRUPT) {
// 中断当前线程
AbstractQueuedSynchronizer.selfInterrupt();
}
}
private void enqueue(E e) {
// 读取底层对象数组
final Object[] items = this.items;
// 插入元素
items[putIndex] = e;
// 递增下一个插入索引，如果已经到达数组长度
if (++putIndex == items.length) {
// 循环更新到数组头部
putIndex = 0;
}
// 递增元素总数
count++;
// 唤醒在非空条件上阻塞等待的单个线程
notEmpty.signal();
}
AbstractQueuedSynchronizer#
/**
* 唤醒在当前条件上阻塞等待的单个线程
*/
public final void signal() {
// 互斥锁没有被当前线程持有
if (!isHeldExclusively()) {
// 则抛出 IllegalMonitorStateException异常
throw new IllegalMonitorStateException();
}
// 读取条件队列中第一个等待的节点
final Node first = firstWaiter;
if (first != null) {
// 将该节点从条件队列转移到同步队列
doSignal(first);
}
}
/**
* 将目标节点从条件队列转移到同步队列中
*/
private void doSignal(Node first) {
do {
// 更新 firstWaiter 为当前节点的后置节点
if ( (firstWaiter = first.nextWaiter) == null) {
// 如果无后置节点
lastWaiter = null;
}
first.nextWaiter = null;
// 转移成功则退出循环
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
/**
* 将形参节点从条件队列转移到同步队列，转移成功返回 true
*/
final boolean transferForSignal(Node node) {
/**
* If cannot change waitStatus, the node has been cancelled.
* 节点在转移前被取消
*/
if (!node.compareAndSetWaitStatus(Node.CONDITION, 0)) {
return false;
}
// 将节点加入到同步队列尾部
final Node p = enq(node);
// 读取其同步状态
final int ws = p.waitStatus;
/**
* 1）转移成功后线程被中断
* 2）原子更新状态失败，即节点被取消
*/
if (ws > 0 || !p.compareAndSetWaitStatus(ws, Node.SIGNAL)) {
// 唤醒驻留其上的线程
LockSupport.unpark(node.thread);
}
return true;
}
@Override
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;
final
// 读取目标元素
E e = (E) items[takeIndex];
// 将目标索引处的元素置空
items[takeIndex] = null;
// 循环递增读取索引
if (++takeIndex == items.length) {
takeIndex = 0;
}
count--;
if (itrs != null) {
itrs.elementDequeued();
}
// 唤醒在非满条件上等待的线程
notFull.signal();
return e;
}
/**
* 1）如果队列已满，则返回 false，元素添加失败。
* 2）如果队列有可用空间，则添加元素，并返回 true。
*/
@Override
public boolean offer(E e) {
Objects.requireNonNull(e);
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 1）队列已满
if (count == items.length) {
return false;
// 2）队列中有可用位置
} else {
enqueue(e);
return true;
}
} finally {
lock.unlock();
}
}
/**
* 1）如果队列有可用位置，则添加元素到队列尾部，并返回 true。
* 2）如果队列已满，在指定的超时时间内队列可用，则添加元素；否则，返回 false，添加失败。
*/
@Override
public boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException {
Objects.requireNonNull(e);
long nanos = unit.toNanos(timeout);
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
while (count == items.length) {
if (nanos <= 0L) {
return false;
}
// 在非满条件上等待指定的超时时间
nanos = notFull.awaitNanos(nanos);
}
enqueue(e);
return true;
} finally {
lock.unlock();
}
}
AbstractQueuedSynchronizer#awaitNanos
/**
* 1）当前线程被设置了中断标识，则抛出 InterruptedException 异常。
* 2）阻塞直到当前线程被唤醒、中断、或超时。
*/
public final long awaitNanos(long nanosTimeout)
throws InterruptedException {
// 如果线程已经被设置了中断标识，则抛出 InterruptedException 异常
if (Thread.interrupted()) {
throw new InterruptedException();
}
// 计算截止时间
final long deadline = System.nanoTime() + nanosTimeout;
final long initialNanos = nanosTimeout;
// 往条件队列中添加节点
final Node node = addConditionWaiter();
// 尝试释放互斥锁
final int savedState = fullyRelease(node);
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
// 如果已经超时
if (nanosTimeout <= 0L) {
// 将节点从条件队列转移到同步队列中
transferAfterCancelledWait(node);
break;
}
// 如果超时时间 > 1000 纳秒
if (nanosTimeout > AbstractQueuedSynchronizer.SPIN_FOR_TIMEOUT_THRESHOLD) {
// 最多阻塞当期线程指定的超时时间
LockSupport.parkNanos(this, nanosTimeout);
}
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) {
break;
}
// 计算剩余时间
nanosTimeout = deadline - System.nanoTime();
}
// 尝试获取互斥锁
if (acquireQueued(node, savedState) && interruptMode != ConditionObject.THROW_IE) {
interruptMode = ConditionObject.REINTERRUPT;
}
if (node.nextWaiter != null) {
unlinkCancelledWaiters();
}
if (interruptMode != 0) {
reportInterruptAfterWait(interruptMode);
}
// 计算剩余时间
final long remaining = deadline - System.nanoTime(); // avoid overflow
return remaining <= initialNanos ? remaining : Long.MIN_VALUE;
}
/**
* 1）如果队列为空，则返回 null
* 2）如果队列非空，则移除并返回队列头部元素
* created by ZXD at 2 Dec 2018 T 09:41:30
* @return
*/
@Override
public E poll() {
final ReentrantLock lock = this.lock;
lock.lock();
try {
return count == 0 ? null : dequeue();
} finally {
lock.unlock();
}
}
/**
* 1）如果队列非空，则移除并返回头部元素。
* 2）如果队列为空，则最多在指定的超时时间内等待队列有元素可用，
* 如果有则移除并返回队列头部；如果已经超时，则返回 null.
*/
@Override
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 <= 0L) {
return null;
}
// 在非空条件上最多阻塞 nanos 纳秒
nanos = notEmpty.awaitNanos(nanos);
}
return dequeue();
} finally {
lock.unlock();
}
}