小舟从此逝,江海寄余生。
先看构造方法
java.util.concurrent.ArrayBlockingQueue#ArrayBlockingQueue(int)
java.util.concurrent.ArrayBlockingQueue#ArrayBlockingQueue(int, boolean)
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();
}
调用put方法
java.util.concurrent.ArrayBlockingQueue#put
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();
}
}
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject#await()
public final void await() throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// 新建节点加入条件队列
Node node = addConditionWaiter();
// 将锁释放
int savedState = fullyRelease(node);
int interruptMode = 0;
// 判断节点是否在同步队列中,如果不在
while (!isOnSyncQueue(node)) {
// 线程阻塞
LockSupport.park(this);
// 后面解析这个方法的作用,主要判断是否到同步队列中了
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 尝试获取锁,这个方法在共享锁里有讲
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null) // 如果条件队列中还有其他节点,剔除无效节点
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject#addConditionWaiter
private Node addConditionWaiter() {
Node t = lastWaiter;
// 尾节点不为空,且状态不为Condition,则认为是死节点,进行清除尾部死节点
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
t = lastWaiter;
}
// 新建一个节点加入队列
Node node = new Node(Thread.currentThread(), Node.CONDITION);
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject#unlinkCancelledWaiters
// 循环进行尾部死节点的清除
private void unlinkCancelledWaiters() {
Node t = firstWaiter;
Node trail = null;
while (t != null) {
Node next = t.nextWaiter;
if (t.waitStatus != Node.CONDITION) {
t.nextWaiter = null;
if (trail == null)
firstWaiter = next;
else
trail.nextWaiter = next;
if (next == null)
lastWaiter = trail;
}
else
trail = t;
t = next;
}
}
java.util.concurrent.locks.AbstractQueuedSynchronizer#fullyRelease
// 把持有锁的次数全部释放
final int fullyRelease(Node node) {
boolean failed = true;
try {
int savedState = getState();
if (release(savedState)) {
failed = false;
return savedState;
} else {
throw new IllegalMonitorStateException();
}
} finally {
if (failed)
node.waitStatus = Node.CANCELLED;
}
}
java.util.concurrent.locks.AbstractQueuedSynchronizer#isOnSyncQueue
final boolean isOnSyncQueue(Node node) {
// 如果是条件队列,状态肯定不是condition,而且是有前驱指针的
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// 如果后继指针不为空,即在同步队列中
if (node.next != null)
return true;
// 都不满足的话从同步队列尾节点向前找,是否跟node指针相同
return findNodeFromTail(node);
}
java.util.concurrent.locks.AbstractQueuedSynchronizer#findNodeFromTail
// 从同步队列尾节点向前找,是否跟node指针相同
private boolean findNodeFromTail(Node node) {
Node t = tail;
for (;;) {
if (t == node)
return true;
if (t == null)
return false;
t = t.prev;
}
}
java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject#checkInterruptWhileWaiting
// 如果现在不是中断的,正常被signal唤醒返回0
// 如果节点由中断加入同步队列则返回THROW_IE,由signal加入同步队列则返回REINTERRUpt
private int checkInterruptWhileWaiting(Node node) {
return Thread.interrupted() ?
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
0;
}
java.util.concurrent.locks.AbstractQueuedSynchronizer#transferAfterCancelledWait
final boolean transferAfterCancelledWait(Node node) {
// 如果是Condition状态,修改为0,并入队同步队列
if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
enq(node);
return true;
}
while (!isOnSyncQueue(node))
Thread.yield();
return false;
}