AQS 원칙
1. 개요
전체 이름은 AbstractQueuedSynchronizer이며 잠금 및 관련 동기화 도구를 차단하기위한 프레임 워크입니다
.
- state 속성을 사용하여 리소스의 상태 (배타적 모드와 공유 모드로 구분됨)를 나타내며, 하위 클래스는이 상태를 유지하는 방법을 정의하고 잠금을 획득 및 해제하는 방법을 제어해야합니다.
- getState-Get 상태
- setState 설정 상태
- 상태 상태를 설정하는 compareAndSetState-cas 메커니즘
- 독점 모드는 하나의 스레드 만 리소스에 액세스 할 수있는 반면 공유 모드는 여러 스레드가 리소스에 액세스 할 수 있도록 허용합니다.
- 모니터의 EntryList와 유사한 FIFO 기반 대기 대기열을 제공합니다.
- 대기 및 깨우기 메커니즘을 실현하기위한 조건 변수는 Monitor의 WaitSet과 유사한 여러 조건 변수를 지원합니다.
하위 클래스는 주로 이러한 메서드를 구현합니다 (기본적으로 UnsupportedOperationException이 throw 됨).
- tryAcquire
- tryRelease
- tryAcquireShared
- tryReleaseShared
- isHeldExclusively
잠금 자세 가져 오기
// 如果获取锁失败
if (!tryAcquire(arg)) {
// 入队, 可以选择阻塞当前线程 park unpark
}잠금을 해제하는 자세
// 如果释放锁成功
if (tryRelease(arg)) {
// 让阻塞线程恢复运行
}3. 경험
유래
초기에 프로그래머는 재진입 잠금을 사용하여 세마포를 구현하는 것과 같은 또 다른 유사한 동기화기를 구현하기 위해 한 가지 유형의 동기화기를 사용했습니다. 이것은 분명히
충분히 우아하지 않기 때문에 AQS는이 범용 동기화 메커니즘을 제공하기 위해 JSR166 (자바 사양 제안)에서 생성되었습니다.
목표
AQS
차단 버전에 의해 달성 될 기능적 목표 잠금 획득 획득 및 비 차단 버전 잠금 획득 시도 tryAcquire
잠금 시간 초과 메커니즘 획득
중단 취소 메커니즘,
독점 메커니즘 및 공유 메커니즘
, 조건이 충족되지 않을 때 대기 메커니즘을 통해
달성해야하는 성능 목표
대신, 여기서 주요 성능 목표는 확장 성입니다. 즉,
특히 동기화 장치가 경쟁하는 경우 에도 효율성을 예측 가능하게 유지하는 것 입니다.
디자인
AQS의 기본 개념은 사실 매우 간단
합니다. 잠금 획득 논리
while(state 状态不允许获取) {
if(队列中还没有此线程) {
入队并阻塞
}
}
当前线程出队잠금 해제 논리
if(state 状态允许了) {
恢复阻塞的线程(s)
}키 포인트
- 상태의 원자 유지
- 스레드 차단 및 재개
- 유지 보수 대기열
1) 상태 디자인
- state는 수정의 원 자성을 보장하기 위해 cas와 함께 volatile을 사용합니다.
- state는 동기화 상태를 유지하기 위해 32bit int를 사용합니다. 그 당시 long을 사용하는 많은 플랫폼에서의 테스트 결과는 이상적이지 않았기 때문입니다.
2) 차단 된 복구 설계
- 스레드 일시 중지 및 다시 시작을 제어하기위한 초기 API에는 일시 중지 및 다시 시작이 포함되지만 다시 시작이 먼저 호출되면 일시 중지가 인식하지 못하므로 사용할 수 없습니다.
- 해결책은 park & unpark를 사용하여 스레드를 일시 중지했다가 다시 시작하는 것입니다. 구체적인 원칙은 이전에 언급 한 바 있으며 unpark 후 park에 문제가 없습니다.
- park & unpark는 동기화 장치가 아닌 스레드 용이므로 제어 단위가 더 세밀합니다.
- 파크 스레드는 인터럽트에 의해 중단 될 수도 있습니다.
3) 대기열 디자인
- FIFO 선입 선출 대기열이 사용되며 우선 순위 대기열은 지원되지 않습니다.
- 디자인은 단방향 잠금없는 대기열 인 CLH 대기열을 사용합니다.
큐에는 두 개의 포인터 노드 인 head와 tail이 있으며, 둘 다 volatile로 수정되고 cas와 함께 사용됩니다. 각 노드에는 노드의 상태를 유지하고 큐에 들어가는 의사 코드가 있습니다. 테일 할당의 원 자성 만 고려해야합니다.
do {
// 原来的 tail
Node prev = tail;
// 用 cas 在原来 tail 的基础上改为 node
} while(tail.compareAndSet(prev, node))큐에서 의사 코드 제거
// prev 是上一个节点
while((Node prev=node.prev).state != 唤醒状态) {
}
// 设置头节点
head = node;CLH 혜택 :
- 잠금 없음, 스핀 사용
- 빠르고 비 차단
AQS는 어떤면에서 CLH를 개선합니다
private Node enq(final Node node) {
for (; ; ) {
Node t = tail;
// 队列中还没有元素 tail 为 null
if (t == null) {
// 将 head 从 null -> dummy
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 将 node 的 prev 设置为原来的 tail
node.prev = t;
// 将 tail 从原来的 tail 设置为 node
if (compareAndSetTail(t, node)) {
// 原来 tail 的 next 设置为 node
t.next = node;
return t;
}
}
}
}AQS에서 주로 사용되는 동시성 도구
ReentrantLock 원칙
1. 불공정 한 잠금의 실행 원칙
잠금 및 잠금 해제 프로세스
생성자부터 시작하겠습니다. 기본값은 불공정 한 잠금 구현입니다.
public ReentrantLock() {
sync = new NonfairSync();
}
경쟁이 없을 때 AQS에서 상속 된 NonfairSync
첫 번째 대회가 나타날 때
Thread-1 실행
1. CAS가 상태를 0에서 1로 변경하려고하는데 결과가 실패 함
2. tryAcquire 로직
으로 들어감 이 때 상태는 이미 1이지만 결과는 여전히 실패 함 3. 다음으로 addWaiter 로직으로 들어가 구성 노드 큐
- 그림의 노란색 삼각형은 노드의 waitStatus 상태를 나타냅니다. 여기서 0은 기본 정상 상태입니다.
- 노드가 느리게 생성되었습니다.
- 첫 번째 노드는 더미 (더미) 또는 센티넬이라고하며 좌석을 차지하는 데 사용되며 스레드와 관련이 없습니다.
현재 쓰레드가 acquireQueued 로직
1 로 들어갑니다 . acquireQueued는 계속해서 무한 루프에서 잠금 획득을 시도하고 실패 후 파크 블록으로 들어갑니다
.2 . 헤드 옆에있는 경우 (2 위) tryAcquire를 다시 시도합니다. 잠금 획득, 물론이 시간 상태 여전히 1, 실패
3. shouldParkAfterFailedAcquire 로직을 입력하고 선행 노드의 waitStatus를 변경, 즉 -1로 향하고 이번에는 false를 리턴합니다.
4. shouldParkAfterFailedAcquire가 실행 된 후 acquireQueued로 돌아가서 다시 tryAcquire로 잠금을 시도합니다. 물론 상태는 여전히 1이며 실패합니다.
5. shouldParkAfterFailedAcquire를 다시 입력하면 이전 노드의 waitStatus가 이미 -1입니다. , 이번에는 true
6을 반환합니다 . parkAndCheckInterrupt, Thread-1 park (회색으로 표시됨)를 입력합니다.
다시 한 번, 여러 스레드가 위의 과정을 경험하고 경쟁에 실패하여 이렇게되었습니다.
Thread-0은 잠금을 해제하고 성공하면 tryRelease 프로세스를 시작합니다.
- exclusiveOwnerThread를 null로 설정하십시오.
- 상태 = 0
현재 큐가 null이 아니고 헤드의 waitStatus = -1이면 unparkSuccessor 프로세스로 들어갑니다.
큐에서 헤드에 가장 가까운 노드를 찾아 (취소되지 않음) unpark 작업을 다시 시작합니다.이 경우 Thread입니다. -1이고
Thread-1로 돌아갑니다.
잠금이 성공하면 (경쟁 없음) 설정됩니다.
- exclusiveOwnerThread 为 Thread-1 ， 상태 = 1
- head는 지금 Thread-1이있는 Node를 가리키고이 Node는 Thread를 지 웁니다.
- 원래 헤드는 연결 목록에서 연결이 끊어져 가비지 수집 될 수 있습니다.
예를 들어이 시점에서 경쟁하는 다른 쓰레드 (불공정 한 표현)가 있다면이 시점에서 쓰레드 -4가 온다
Thread-4에 의해 다시 선점되는 경우
- Thread-4가 exclusiveOwnerThread로 설정 됨, 상태 = 1
- Thread-1이 다시 acquireQueued 프로세스에 진입하고 잠금을 획득하지 못하고 차단을 위해 파크에 다시 진입합니다.
소스 코드 잠금
import com.sun.corba.se.impl.orbutil.concurrent.Sync;
import java.util.concurrent.locks.LockSupport;
// Sync 继承自 AQS
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
// 加锁实现
final void lock() {
// 首先用 cas 尝试（仅尝试一次）将 state 从 0 改为 1, 如果成功表示获得了独占锁
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
// 如果尝试失败，进入 ㈠
acquire(1);
}
// ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
public final void acquire(int arg) {
// ㈡ tryAcquire
if (
!tryAcquire(arg) &&
// 当 tryAcquire 返回为 false 时, 先调用 addWaiter ㈣, 接着 acquireQueued ㈤
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
) {
selfInterrupt();
}
}
// ㈡ 进入 ㈢
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
// ㈢ Sync 继承过来的方法, 方便阅读, 放在此处
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 如果还没有获得锁
if (c == 0) {
// 尝试用 cas 获得, 这里体现了非公平性: 不去检查 AQS 队列
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
else if (current == getExclusiveOwnerThread()) {
// state++
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
// 获取失败, 回到调用处
return false;
}
// ㈣ AQS 继承过来的方法, 方便阅读, 放在此处
private Node addWaiter(Node mode) {
// 将当前线程关联到一个 Node 对象上, 模式为独占模式
Node node = new Node(Thread.currentThread(), mode);
// 如果 tail 不为 null, cas 尝试将 Node 对象加入 AQS 队列尾部
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
// 双向链表
pred.next = node;
return node;
}
}
// 尝试将 Node 加入 AQS, 进入 ㈥
enq(node);
return node;
}
// ㈥ AQS 继承过来的方法, 方便阅读, 放在此处
private Node enq(final Node node) {
for (; ; ) {
Node t = tail;
if (t == null) {
// 还没有, 设置 head 为哨兵节点（不对应线程，状态为 0）
if (compareAndSetHead(new Node())) {
tail = head;
}
} else {
// cas 尝试将 Node 对象加入 AQS 队列尾部
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
// ㈤ AQS 继承过来的方法, 方便阅读, 放在此处
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (; ; ) {
final Node p = node.predecessor();
// 上一个节点是 head, 表示轮到自己（当前线程对应的 node）了, 尝试获取
if (p == head && tryAcquire(arg)) {
// 获取成功, 设置自己（当前线程对应的 node）为 head
setHead(node);
// 上一个节点 help GC
p.next = null;
failed = false;
// 返回中断标记 false
return interrupted;
}
if (
// 判断是否应当 park, 进入 ㈦
shouldParkAfterFailedAcquire(p, node) &&
// park 等待, 此时 Node 的状态被置为 Node.SIGNAL ㈧
parkAndCheckInterrupt()
) {
interrupted = true;
}
}
} finally {
if (failed)
cancelAcquire(node);
}
}
// ㈦ AQS 继承过来的方法, 方便阅读, 放在此处
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 获取上一个节点的状态
int ws = pred.waitStatus;
if (ws == Node.SIGNAL) {
// 上一个节点都在阻塞, 那么自己也阻塞好了
return true;
}
// > 0 表示取消状态
if (ws > 0) {
// 上一个节点取消, 那么重构删除前面所有取消的节点, 返回到外层循环重试
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 这次还没有阻塞
// 但下次如果重试不成功, 则需要阻塞，这时需要设置上一个节点状态为 Node.SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
// ㈧ 阻塞当前线程
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
}참고
언 파크의 필요성은 현재 노드의 waitStatus가 아니라 현재 노드의 선행 노드의 waitStatus == Node.SIGNAL에 의해 결정됩니다.
소스 코드 잠금 해제
import com.sun.corba.se.impl.orbutil.concurrent.Sync;
import java.util.concurrent.locks.LockSupport;
// Sync 继承自 AQS
static final class NonfairSync extends Sync {
// 解锁实现
public void unlock() {
sync.release(1);
}
// AQS 继承过来的方法, 方便阅读, 放在此处
public final boolean release(int arg) {
// 尝试释放锁, 进入 ㈠
if (tryRelease(arg)) {
// 队列头节点 unpark
Node h = head;
if (
// 队列不为 null
h != null &&
// waitStatus == Node.SIGNAL 才需要 unpark
h.waitStatus != 0
) {
// unpark AQS 中等待的线程, 进入 ㈡
unparkSuccessor(h);
}
return true;
}
return false;
}
// ㈠ Sync 继承过来的方法, 方便阅读, 放在此处
protected final boolean tryRelease(int releases) {
// state--
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 支持锁重入, 只有 state 减为 0, 才释放成功
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
// ㈡ AQS 继承过来的方法, 方便阅读, 放在此处
private void unparkSuccessor(Node node) {
// 如果状态为 Node.SIGNAL 尝试重置状态为 0
// 不成功也可以
int ws = node.waitStatus;
if (ws < 0) {
compareAndSetWaitStatus(node, ws, 0);
}
// 找到需要 unpark 的节点, 但本节点从 AQS 队列中脱离, 是由唤醒节点完成的
Node s = node.next;
// 不考虑已取消的节点, 从 AQS 队列从后至前找到队列最前面需要 unpark 的节点
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
}2. 재진입의 원리
import com.sun.corba.se.impl.orbutil.concurrent.Sync;
static final class NonfairSync extends Sync {
// ...
// Sync 继承过来的方法, 方便阅读, 放在此处
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
else if (current == getExclusiveOwnerThread()) {
// state++
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// Sync 继承过来的方法, 方便阅读, 放在此处
protected final boolean tryRelease(int releases) {
// state--
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 支持锁重入, 只有 state 减为 0, 才释放成功
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
}3. 인터럽트 가능 원리
무중단 모드
이 모드에서는 중단 되더라도 AQS 대기열에 계속 남아 있으며 잠금을 획득 할 때까지 중단되었음을 알 수 없습니다.
import com.sun.corba.se.impl.orbutil.concurrent.Sync;
import java.util.concurrent.locks.LockSupport;
// Sync 继承自 AQS
static final class NonfairSync extends Sync {
// ...
private final boolean parkAndCheckInterrupt() {
// 如果打断标记已经是 true, 则 park 会失效
LockSupport.park(this);
// interrupted 会清除打断标记
return Thread.interrupted();
}
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (; ; ) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null;
failed = false;
// 还是需要获得锁后, 才能返回打断状态
return interrupted;
}
if (
shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()
) {
// 如果是因为 interrupt 被唤醒, 返回打断状态为 true
interrupted = true;
}
}
} finally {
if (failed)
cancelAcquire(node);
}
}
public final void acquire(int arg) {
if (
!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
) {
// 如果打断状态为 true
selfInterrupt();
}
}
static void selfInterrupt() {
// 重新产生一次中断
Thread.currentThread().interrupt();
}
}인터럽트 가능 모드
import com.sun.corba.se.impl.orbutil.concurrent.Sync;
static final class NonfairSync extends Sync {
public final void acquireInterruptibly(int arg) throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// 如果没有获得到锁, 进入 ㈠
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}
// ㈠ 可打断的获取锁流程
private void doAcquireInterruptibly(int arg) throws InterruptedException {
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (; ; ) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()) {
// 在 park 过程中如果被 interrupt 会进入此
// 这时候抛出异常, 而不会再次进入 for (;;)
throw new InterruptedException();
}
}
} finally {
if (failed)
cancelAcquire(node);
}
}
}4. Fair Lock 구현 원칙
import com.sun.corba.se.impl.orbutil.concurrent.Sync;
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
// AQS 继承过来的方法, 方便阅读, 放在此处
public final void acquire(int arg) {
if (
!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
) {
selfInterrupt();
}
}
// 与非公平锁主要区别在于 tryAcquire 方法的实现
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 先检查 AQS 队列中是否有前驱节点, 没有才去竞争
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
} else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
// ㈠ AQS 继承过来的方法, 方便阅读, 放在此处
public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
// h != t 时表示队列中有 Node
return h != t &&
(
// (s = h.next) == null 表示队列中还有没有老二
(s = h.next) == null ||
// 或者队列中老二线程不是此线程
s.thread != Thread.currentThread()
);
}
}5. 조건 변수의 실현 원리
각 조건 변수는 실제로 대기 대기열에 해당하며 해당 구현 클래스는 ConditionObject입니다.
프로세스를 기다리다
Thread-0을 시작하여 잠금을 유지하고, await를 호출하고, ConditionObject의 addConditionWaiter 프로세스를 입력하고
, 새 노드 상태를 -2 (Node.CONDITION)로 만들고, Thread-0을 연결하고, 대기 대기열 끝에 추가합니다.
다음으로 AQS의 fullyRelease 프로세스를 입력하여 동기화 장치의 잠금을 해제하십시오.
Unpark AQS 대기열의 다음 노드는 잠금을 위해 경쟁합니다. 다른 경쟁 스레드가 없다고 가정하면 Thread-1이 성공적으로 경쟁합니다.
공원 차단 스레드 -0
신호 처리
Thread-1이 Thread-0을 깨우고 싶다고 가정합니다.
ConditionObject의 doSignal 프로세스에 들어가서 Thread-0이있는 Node 인 대기 대기열에서 첫 번째 Node를 가져옵니다.
transferForSignal 프로세스를 실행하고, 노드를 AQS 대기열 끝에 추가하고, Thread-0의 waitStatus를 0으로 변경하고, Thread-3의 waitStatus를 -1로 변경합니다.
Thread-1은 잠금을 해제하고 잠금 해제 프로세스를 시작합니다.
소스 코드
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;
public class ConditionObject implements Condition, java.io.Serializable {
private static final long serialVersionUID = 1173984872572414699L;
// 第一个等待节点
private transient Node firstWaiter;
// 最后一个等待节点
private transient Node lastWaiter;
public ConditionObject() {
}
// ㈠ 添加一个 Node 至等待队列
private Node addConditionWaiter() {
Node t = lastWaiter;
// 所有已取消的 Node 从队列链表删除, 见 ㈡
if (t != null && t.waitStatus != Node.CONDITION) {
unlinkCancelledWaiters();
t = lastWaiter;
}
// 创建一个关联当前线程的新 Node, 添加至队列尾部
Node node = new Node(Thread.currentThread(), Node.CONDITION);
if (t == null)
firstWaiter = node;
else
t.nextWaiter = node;
lastWaiter = node;
return node;
}
// 唤醒 - 将没取消的第一个节点转移至 AQS 队列
private void doSignal(Node first) {
do {
// 已经是尾节点了
if ((firstWaiter = first.nextWaiter) == null) {
lastWaiter = null;
}
first.nextWaiter = null;
} while (
// 将等待队列中的 Node 转移至 AQS 队列, 不成功且还有节点则继续循环 ㈢
!transferForSignal(first) &&
// 队列还有节点
(first = firstWaiter) != null
);
}
// 外部类方法, 方便阅读, 放在此处
// ㈢ 如果节点状态是取消, 返回 false 表示转移失败, 否则转移成功
final boolean transferForSignal(Node node) {
// 如果状态已经不是 Node.CONDITION, 说明被取消了
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 加入 AQS 队列尾部
Node p = enq(node);
int ws = p.waitStatus;
if (
// 上一个节点被取消
ws > 0 ||
// 上一个节点不能设置状态为 Node.SIGNAL
!compareAndSetWaitStatus(p, ws, Node.SIGNAL)
) {
// unpark 取消阻塞, 让线程重新同步状态
LockSupport.unpark(node.thread);
}
return true;
}
// 全部唤醒 - 等待队列的所有节点转移至 AQS 队列
private void doSignalAll(Node first) {
lastWaiter = firstWaiter = null;
do {
Node next = first.nextWaiter;
first.nextWaiter = null;
transferForSignal(first);
first = next;
} while (first != null);
}
// ㈡
private void unlinkCancelledWaiters() {
// ...
}
// 唤醒 - 必须持有锁才能唤醒, 因此 doSignal 内无需考虑加锁
public final void signal() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignal(first);
}
// 全部唤醒 - 必须持有锁才能唤醒, 因此 doSignalAll 内无需考虑加锁
public final void signalAll() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignalAll(first);
}
// 不可打断等待 - 直到被唤醒
public final void awaitUninterruptibly() {
// 添加一个 Node 至等待队列, 见 ㈠
Node node = addConditionWaiter();
// 释放节点持有的锁, 见 ㈣
int savedState = fullyRelease(node);
boolean interrupted = false;
// 如果该节点还没有转移至 AQS 队列, 阻塞
while (!isOnSyncQueue(node)) {
// park 阻塞
LockSupport.park(this);
// 如果被打断, 仅设置打断状态
if (Thread.interrupted())
interrupted = true;
}
// 唤醒后, 尝试竞争锁, 如果失败进入 AQS 队列
if (acquireQueued(node, savedState) || interrupted)
selfInterrupt();
}
// 外部类方法, 方便阅读, 放在此处
// ㈣ 因为某线程可能重入，需要将 state 全部释放
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;
}
}
// 打断模式 - 在退出等待时重新设置打断状态
private static final int REINTERRUPT = 1;
// 打断模式 - 在退出等待时抛出异常
private static final int THROW_IE = -1;
// 判断打断模式
private int checkInterruptWhileWaiting(Node node) {
return Thread.interrupted() ?
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
0;
}
// ㈤ 应用打断模式
private void reportInterruptAfterWait(int interruptMode)
throws InterruptedException {
if (interruptMode == THROW_IE)
throw new InterruptedException();
else if (interruptMode == REINTERRUPT)
selfInterrupt();
}
// 等待 - 直到被唤醒或打断
public final void await() throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
}
// 添加一个 Node 至等待队列, 见 ㈠
Node node = addConditionWaiter();
// 释放节点持有的锁
int savedState = fullyRelease(node);
int interruptMode = 0;
// 如果该节点还没有转移至 AQS 队列, 阻塞
while (!isOnSyncQueue(node)) {
// park 阻塞
LockSupport.park(this)
// 如果被打断, 退出等待队列
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 退出等待队列后, 还需要获得 AQS 队列的锁
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 所有已取消的 Node 从队列链表删除, 见 ㈡
if (node.nextWaiter != null)
unlinkCancelledWaiters();
// 应用打断模式, 见 ㈤
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
// 等待 - 直到被唤醒或打断或超时
public final long awaitNanos(long nanosTimeout) throws InterruptedException {
if (Thread.interrupted()) {
throw new InterruptedException();
}
// 添加一个 Node 至等待队列, 见 ㈠
Node node = addConditionWaiter();
// 释放节点持有的锁
int savedState = fullyRelease(node);
// 获得最后期限
final long deadline = System.nanoTime() + nanosTimeout;
int interruptMode = 0;
// 如果该节点还没有转移至 AQS 队列, 阻塞
while (!isOnSyncQueue(node)) {
// 已超时, 退出等待队列
if (nanosTimeout <= 0L) {
transferAfterCancelledWait(node);
break;
}
// park 阻塞一定时间, spinForTimeoutThreshold 为 1000 ns
if (nanosTimeout >= spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
// 如果被打断, 退出等待队列
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
nanosTimeout = deadline - System.nanoTime();
}
// 退出等待队列后, 还需要获得 AQS 队列的锁
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 所有已取消的 Node 从队列链表删除, 见 ㈡
if (node.nextWaiter != null)
unlinkCancelledWaiters();
// 应用打断模式, 见 ㈤
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return deadline - System.nanoTime();
}
// 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
public final boolean awaitUntil(Date deadline) throws InterruptedException {
// ...
}
// 等待 - 直到被唤醒或打断或超时, 逻辑类似于 awaitNanos
public final boolean await(long time, TimeUnit unit) throws InterruptedException {
// ...
}
// 工具方法 省略 ...
}