简介
Condition
通过Lock
接口的newCondition
方法创建,因此需要在获取到锁之后,才能调用Condition
的等待/通知方法,这一点与Object
的监视器方法类似。
另一点与Object.wait
相似的是,Condition.await
方法也会自动释放相关联的锁,并将当前线程挂起。
接口详解
await()
调用await()
方法后,Condition
相关联的锁会自动释放,当前线程会被挂起并进入休眠状态,该方法会响应中断,以下4种场景可以唤醒线程:
- 其他线程调用该
Condition
的notify
方法,同时当前线程被系统选为唤醒的线程; - 其他线程调用该
Condition
的notifyAll
方法; - 其他线程中断当前线程,同时系统支持休眠线程的中断操作;
- 发生虚假唤醒 (spurious wakeup)
awaitUninterruptibly()
调用awaitUninterruptibly()
方法后,Condition
相关联的锁会自动释放,当前线程会被挂起并进入休眠状态,该方法不响应中断,以下3种场景可以唤醒线程:
- 其他线程调用该
Condition
的notify
方法,同时当前线程被系统选为唤醒的线程; - 其他线程调用该
Condition
的notifyAll
方法; - 发生虚假唤醒 (spurious wakeup)
awaitNanos(long nanosTimeout)、await(long time, TimeUnit unit)、awaitUntil(Date deadline)
调用该方法后,当前线程进入等待状态,直到被唤醒、中断或者超时,并且Condition
相关联的锁会自动释放。
以下5种场景可以唤醒线程:
- 其他线程调用该
Condition
的notify
方法,同时当前线程被系统选为唤醒的线程; - 其他线程调用该
Condition
的notifyAll
方法; - 其他线程中断当前线程,同时支持休眠线程的中断操作;
- 等待超时;
- 发生虚假唤醒 (spurious wakeup)
signal()
调用signal()
之后,系统会挑选一个调用过await
方法的线程进行唤醒,唤醒的线程需要重新尝试获取锁,才能继续往下执行。
调用signal()
方法的线程需要获取到Condition
相关联的锁,否则会抛出IllegalMonitorStateException
异常。
signalAll()
调用signalAll()
方法后,会唤醒所有等待的线程,但是每个线程想要往下执行需要重新获取锁,否则会处于阻塞状态。
ConditionObject实现
ConditionObject
是Condition
接口的实现类,是AbstractQueuedSynchronizer
(即AQS)的一个内部类。ReentrantLock
的newCondition
方法创建的就是ConditionObject
实例,因此我们着重研究下其实现。
数据结构
//等待队列的头结点
private transient Node firstWaiter;
//等待队列的尾结点
private transient Node lastWaiter;
//
private static final int REINTERRUPT = 1;
//
private static final int THROW_IE = -1;
等待队列是单向链表,指针是nexiWiater
,同时具有头尾指针。Node
结点的数据结构参见之前的《AQS详解》。
方法详解
await()
await
方法会将当前线程结点添加到等待队列中,并释放当前线程获取到的锁,并且阻塞当前线程,当被其他线程唤醒时,当前线程需要重新获取到锁才能继续执行。
public final void await() throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
//添加到等待队列
Node node = addConditionWaiter();
//释放当前线程获取的资源
int savedState = fullyRelease(node);
int interruptMode = 0;
/**
* 此处的逻辑为:
* 第一次循环时,由于结点的waitStatus为CONDITION,因此会进入到while内部代码中,使用LockSupport.park使线程阻塞。
* 要唤醒线程,基本有两种方式:一种是使用signal()或signalAll()方法唤醒;另一种则是发生中断。
*/
//判断当前结点是否在同步队列中,当使用signal或signalAll唤醒、或者发生中断,结点都会进入同步队列中,才会跳过while循环,执行后续代码
while (!isOnSyncQueue(node)) {
//阻塞当前线程
LockSupport.park(this);
//awit方法响应中断,此处判断线程等待过程中是否被中断
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);
}
/**
* 检查中断:
* 未中断返回0
* 被唤醒前中断返回 THROW_IE
* 被唤醒后中断返回 REINTERRUPT
*/
private int checkInterruptWhileWaiting(Node node) {
return Thread.interrupted() ?
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) : 0;
}
/**
* 尝试将节点状态从CONDITION状态置为0
* 如果设置成功,证明没有调用sign或signAll方法,线程唤醒是因为发生中断,因此将结点加入同步队列,并返回true。
* 如果设置不成功,则时通过sign或signAll唤醒,返回false
*/
final boolean transferAfterCancelledWait(Node node) {
//将节点状态从CONDITION状态置为0,设置成功加入同步队列中
if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
enq(node);
return true;
}
while (!isOnSyncQueue(node))
Thread.yield();
return false;
}
/**
* 如果interruptMode为THROW_IE,即在sign之前发送中断,则抛出InterruptedException。
* 如果interruptMode为REINTERRUPT,即在sign之后发生中断,则调用interrupt方法,将中断补上。
*/
private void reportInterruptAfterWait(int interruptMode) throws InterruptedException {
if (interruptMode == THROW_IE)
throw new InterruptedException();
else if (interruptMode == REINTERRUPT)
selfInterrupt();
}
addConditionWaiter()
addConditionWaiter
方法将线程结点添加到等待队列的队尾。
private Node addConditionWaiter() {
Node t = lastWaiter;
// If lastWaiter is cancelled, clean out.
if (t != null && t.waitStatus != Node.CONDITION) {
//将等待队列中等待状态不等于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;
}
isOnSyncQueue(Node)
isOnSyncQueue
方法主要用于判断当前结点是否在同步队列中
final boolean isOnSyncQueue(Node node) {
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// If has successor, it must be on queue
if (node.next != null)
return true;
return findNodeFromTail(node);
}
private boolean findNodeFromTail(Node node) {
Node t = tail;
for (;;) {
if (t == node)
return true;
if (t == null)
return false;
t = t.prev;
}
}
unlinkCancelledWaiters()
unlinkCancelledWaiters
方法主要将等待队列中等待状态不等于CONDITION
的结点从队列中剔除。
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;
}
}
fullyRelease(Node)
fullyRelease
方法释放当前线程结点的资源,因为ReentrantLock
只有一个资源,因此ReentrantLock
创建的Condition
的await
方法相当于释放锁。
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;
}
}
signal()
signal
方法只唤醒等待队列的头结点,并将头结点出队列,加到同步队列队尾。
signal
方法需要获取锁才能调用,否则抛出IllegalMonitorStateException异常。
public final void signal() {
//该方法由子类实现,例如ReentrantLock
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
//只唤醒等待队列的头结点
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
doSignal(Node)
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
//头结点出condition队列
first.nextWaiter = null;
} while (!transferForSignal(first) && (first = firstWaiter) != null);
}
final boolean transferForSignal(Node node) {
//将结点状态重置为0
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
//将当前结点加入同步队列
Node p = enq(node);
int ws = p.waitStatus;
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true;
}
signalAll()
signalAll
方法会清空condition队列,并将condition队列中所有的结点都加入到同步队列中。
signalAll
方法需要获取锁才能调用,否则抛出IllegalMonitorStateException异常。
public final void signalAll() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignalAll(first);
}
doSignalAll(Node)
private void doSignalAll(Node first) {
lastWaiter = firstWaiter = null;
do {
Node next = first.nextWaiter;
first.nextWaiter = null;
transferForSignal(first);
first = next;
} while (first != null);
}