使用示例
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
lock.lock();
System.out.println(Thread.currentThread().getName() + " 开始处理任务");
try {
condition.await();
System.out.println(Thread.currentThread().getName() + " 结束处理任务");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
lock.lock();
System.out.println(Thread.currentThread().getName() + " 开始处理任务");
try {
condition.signal();
System.out.println(Thread.currentThread().getName() + " 结束处理任务");
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
- 调用
Condition#await方法会释放当前持有的锁，然后阻塞当前线程，同时向Condition队列尾部添加一个个节点，所以调用Condition#await方法的时候必须持有锁
- 调用
Condition#signal方法会将Condition队列的首节点移动到阻塞队列尾部，然后唤醒因调用Condition#await方法而阻塞的线程(唤醒之后这个线程就可以去竞争锁了)，所以调用Condition#signal方法的时候必须持有锁，持有锁的线程唤醒被因调用Condition#await方法而阻塞的线程
ReentrantLock#newCondition
public Condition newCondition() {
return sync.newCondition();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
public class ConditionObject implements Condition, java.io.Serializable {
}
Condition
- 每个
Condition实例对应一个单向链表，尾进头出，整个队列有一个头指针和一个尾指针，通过后驱指针连接起来
- 调用
Condition#await方法会阻塞当前线程，并向Condition队列尾部添加一个节点，节点的数据结构和阻塞队列中的节点数据结构完全一样，只不过nextWaiter == CONDITION
- 调用
Condition#signal方法会唤醒Condition队列中的头结点，并向该节点添加到阻塞队列的尾部
-
ConditionObject是AbstractQueuedSynchronizer中的一个内部类，也就说，这是AQS对Condition的实现
Condition#await
public final void await() throws InterruptedException {
// 响应中断
if (Thread.interrupted())
throw new InterruptedException();
// 向 Condition队列 添加一个尾节点
Node node = addConditionWaiter();
// 释放阻塞队列中的锁，及调用`release`方法释放锁，然后唤醒head节点的下一个节点
int savedState = fullyRelease(node);
int interruptMode = 0;
// 判断该节点是否在阻塞队列中
while (!isOnSyncQueue(node)) {
// 如果不在阻塞队列中，这阻塞当前线程，等待 ConditionObject#signal 方法唤醒
LockSupport.park(this);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 通过执行 ConditionObject#signal 方法唤醒节点后，继续往下执行，这时候需要重新获取锁
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
Condition#addConditionWaiter
private Node addConditionWaiter() {
Node t = lastWaiter;
// If lastWaiter is cancelled, clean out.
if (t != null && t.waitStatus != Node.CONDITION) {
// 将 `Condition队列` 中 `waitStatus != Node.CONDITION` 的节点删除
unlinkCancelledWaiters();
// 删除之后可能尾节点已经改变了，需要重新赋值
t = lastWaiter;
}
Node node = new Node(Thread.currentThread(), Node.CONDITION);
if (t == null)
// 如果Condition队列为空，则设置头指针
firstWaiter = node;
else
// 如果Condition队列不为空，让目前的尾节点的的后驱指针指向它
t.nextWaiter = node;
// 将当前节点设置为尾节点
lastWaiter = node;
return node;
}
- 如果
Condition队列为空，向队列中添加一个头节点
- 如果
Condition队列不为空，向尾部添加一个节点
Condition#signal
public final void signal() {
// 当前线程持有锁才能唤醒首节点
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
// 唤醒首节点
doSignal(first);
}
- 判断当前线程是否持有锁，只有持有锁才能调用
ConditionObject#signal方法
- 唤醒首节点
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
// 脱离 Condition队列 首节点 help GC
first.nextWaiter = null;
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
final boolean transferForSignal(Node node) {
/*
* If cannot change waitStatus, the node has been cancelled.
*/
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 将Condition队列中的首节点添加到阻塞队列的尾部， end方法返回的是入参的前驱节点， 这将会导致ConditionObject#await方法中的 `!isOnSyncQueue(node)` 不成立
Node p = enq(node);
int ws = p.waitStatus;
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
// 唤醒调用 ConditionObject#await 方法的线程
LockSupport.unpark(node.thread);
return true;
}
```
