AQS是JUC鎖框架中最重要的類，通過它來實現獨佔鎖和共享鎖的。
本章是對AbstractQueuedSynchronizer源碼的完全解析，分爲四個部分介紹：
- CLH隊列即同步隊列：儲存着所有等待鎖的線程
- 獨佔鎖
- 共享鎖
- Condition條件
注: 還有一個AbstractQueuedLongSynchronizer類，它與AQS功能和實現幾乎一樣，唯一不同的是AQLS中代表鎖被獲取次數的成員變量state類型是long長整類型，而AQS中該成員變量是int類型。
一. CLH隊列(線程同步隊列)
因爲獲取鎖是有條件的，沒有獲取鎖的線程就要阻塞等待，那麼就要存儲這些等待的線程。
在AQS中我們使用CLH隊列儲存這些等待的線程，但它並不是直接儲存線程，而是儲存擁有線程的node節點。所以先介紹重要內部類Node。
static final class Node {
// 共享模式的標記
static final Node SHARED = new Node();
// 獨佔模式的標記
static final Node EXCLUSIVE = null;
// waitStatus變量的值，標誌着線程被取消
static final int CANCELLED = 1;
// waitStatus變量的值，標誌着後繼線程(即隊列中此節點之後的節點)需要被阻塞.(用於獨佔鎖)
static final int SIGNAL = -1;
// waitStatus變量的值，標誌着線程在Condition條件上等待阻塞.(用於Condition的await等待)
static final int CONDITION = -2;
// waitStatus變量的值，標誌着下一個acquireShared方法線程應該被允許。(用於共享鎖)
static final int PROPAGATE = -3;
// 標記着當前節點的狀態，默認狀態是0, 小於0的狀態都是有特殊作用，大於0的狀態表示已取消
volatile int waitStatus;
// prev和next實現的雙向鏈表
volatile Node prev;
volatile Node next;
// 該節點擁有的線程
volatile Thread thread;
// 可能有兩種作用：
// 1. 表示下一個在Condition條件上等待的節點
// 2. 表示是共享模式或者獨佔模式，注意第一種情況節點一定是共享模式
Node nextWaiter;
// 是不是共享模式
final boolean isShared() {
return nextWaiter == SHARED;
}
// 返回前一個節點prev，如果爲null，則拋出NullPointerException異常
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
// 用於創建鏈表頭head，或者共享模式SHARED
Node() {
}
// 使用在addWaiter方法中
Node(Thread thread, Node mode) {
this.nextWaiter = mode;
this.thread = thread;
}
// 使用在Condition條件中
Node(Thread thread, int waitStatus) {
this.waitStatus = waitStatus;
this.thread = thread;
}
}
重要的成員屬性：
- waitStatus: 表示當前節點的狀態，默認狀態是0。總共有五個值CANCELLED、SIGNAL、CONDITION、PROPAGATE以及0。
- prev和next：記錄着當前節點前一個節點和後一個節點的引用。
- thread：當前節點擁有的線程。當擁有鎖的線程釋放鎖的時候，可能會調用LockSupport.unpark(thread)，喚醒這個被阻塞的線程。
- nextWaiter：如果是SHARED，表示當前節點是共享模式，如果是null，當前節點是獨佔模式，如果是其他值，當前節點也是獨佔模式，不過這個值也是Condition隊列的下一個節點。
注意：通過Node我們可以實現兩個隊列，一是通過prev和next實現CLH隊列(線程同步隊列,雙向隊列)，二是nextWaiter實現Condition條件上的等待線程隊列(單向隊列)，後一個我們在Condition中介紹。
1.2 操作CLH隊列
1.2.1 存儲CLH隊列
// 頭隊列
private transient volatile Node head;
//尾隊列
private transient volatile Node tail;
1.2.2 設置CLH隊列頭head
/**
* CAS方法設置隊列頭，僅在enq方法中使用
*/
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}
這個方法只在enq方法中調用，通過CAS函數設置head值，保證多線程安全
/**
* 重新設置隊列頭，僅在acquire中使用
*/
private void setHead(Node node) {
head = node;
// 線程已經沒有意義了，因爲線程已經獲取到鎖了
node.thread = null;
// 前一個節點已經沒有意義了
node.prev = null;
}
這個方法只在acquire系列的方法中調用，重新設置head，表示移除一些等待線程節點。
1.2.3 設置CLH隊列尾tail
/**
* 通過CAS設置tail，僅在enq中使用
*/
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
這個方法只在enq方法中調用，通過CAS函數設置tail值，保證多線程安全
1.2.4 將一個節點插入到CLH隊列尾
/**
* 向隊尾插入新節點，如果隊列沒有初始化，就先初始化。返回原先隊尾節點
*/
private Node enq(final Node node) {
for (;;) {
Node t = tail;
// t爲null，表示隊列爲空，需先初始化隊列
if (t == null) {
// 採用CAS函數即原子操作方式，設置隊列頭head值
// 如果成功，再將head賦值給隊尾tail。
// 如果失敗，表示head已經被其他線程使用，那麼就那麼就進入下一次循環
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 新添加的node節點的前一個節點prev指向原來的隊列尾tail
node.prev = t;
// 採用CAS函數即原子操作方式，設置新隊列尾tail值。
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
這個方法向CLH隊列尾插入一個新節點，如果隊列爲空，就先創建隊列再插入新節點，返回老的隊列尾節點。
1.2.5 將當前線程添加到CLH隊列尾
// 通過給定的模式mode(獨佔或者共享)爲當前線程創建新節點，並插入隊列中
private Node addWaiter(Node mode) {
// 爲當前線程創建新的節點
// 這個構造方法前面介紹過，用來指定是獨佔還是共享
Node node = new Node(Thread.currentThread(), mode);
// 嘗試enq的快速路徑；失敗時備份到完全enq, 原註釋（實際就是截取enq常規代碼，提高效率）
Node pred = tail;
// 如果隊列已經創建則向隊尾加入新的節點
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 如果沒有創建，通過enq方法創建隊列，並插入新的節點。
//（一般都創建了，所以把上部分代碼提取出來）
enq(node);
return node;
}
爲當前線程創建一個新節點，再插入到CLH隊列尾，返回新創建的節點。
附錄
package java.util.concurrent.locks;
import sun.misc.Unsafe;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
private static final long serialVersionUID = 7373984972572414691L;
protected AbstractQueuedSynchronizer() { }
static final class Node {
// 共享模式的標記
static final Node SHARED = new Node();
// 獨佔模式的標記
static final Node EXCLUSIVE = null;
// waitStatus變量的值，標誌着線程被取消
static final int CANCELLED = 1;
// waitStatus變量的值，標誌着後繼線程(即隊列中此節點之後的節點)需要被阻塞.(用於獨佔鎖)
static final int SIGNAL = -1;
// waitStatus變量的值，標誌着線程在Condition條件上等待阻塞.(用於Condition的await等待)
static final int CONDITION = -2;
// waitStatus變量的值，標誌着下一個acquireShared方法線程應該被允許。(用於共享鎖)
static final int PROPAGATE = -3;
// 標記着當前節點的狀態，默認狀態是0, 小於0的狀態都是有特殊作用，大於0的狀態表示已取消
volatile int waitStatus;
// prev和next實現一個雙向鏈表
volatile Node prev;
volatile Node next;
// 該節點擁有的線程
volatile Thread thread;
// 可能有兩種作用：1. 表示下一個在Condition條件上等待的節點
// 2. 表示是共享模式或者獨佔模式，注意第一種情況節點一定是共享模式
Node nextWaiter;
// 是不是共享模式
final boolean isShared() {
return nextWaiter == SHARED;
}
// 返回前一個節點prev，如果爲null，則拋出NullPointerException異常
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
// 用於創建鏈表頭head，或者共享模式SHARED
Node() {
}
// 使用在addWaiter方法中
Node(Thread thread, Node mode) {
this.nextWaiter = mode;
this.thread = thread;
}
// 使用在Condition條件中
Node(Thread thread, int waitStatus) {
this.waitStatus = waitStatus;
this.thread = thread;
}
}
// CLH隊列頭
private transient volatile Node head;
// CLH隊列尾
private transient volatile Node tail;
// 用來記錄當前鎖被獲取的次數，當state==0，表示還沒有被任何線程獲取
private volatile int state;
protected final int getState() {
return state;
}
protected final void setState(int newState) {
state = newState;
}
// 採用CAS函數。比較並交換函數，它是原子操作函數；即，通過CAS操作的數據都是以原子方式進行的
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
// Queuing utilities
static final long spinForTimeoutThreshold = 1000L;
// 向隊列尾插入新節點，如果隊列沒有初始化，就先初始化。返回原先的隊列尾節點
private Node enq(final Node node) {
for (;;) {
Node t = tail;
// t爲null，表示隊列爲空，先初始化隊列
if (t == null) {
// 採用CAS函數即原子操作方式，設置隊列頭head值。
// 如果成功，再將head值賦值給鏈表尾tail。如果失敗，表示head值已經被其他線程，那麼就進入循環下一次
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 新添加的node節點的前一個節點prev指向原來的隊列尾tail
node.prev = t;
// 採用CAS函數即原子操作方式，設置新隊列尾tail值。
if (compareAndSetTail(t, node)) {
// 設置老的隊列尾tail的下一個節點next指向新添加的節點node
t.next = node;
return t;
}
}
}
}
// 通過給定的模式mode(獨佔或者共享)爲當前線程創建新節點，並插入隊列中
private Node addWaiter(Node mode) {
// 爲當前線程創建新的節點
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
// 如果隊列已經創建，就將新節點插入隊列尾。
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 如果隊列沒有創建，通過enq方法創建隊列，並插入新的節點。
enq(node);
return node;
}
// 重新設置隊列頭head，它只在acquire系列的方法中調用
private void setHead(Node node) {
head = node;
// 線程也沒有意義了，因爲該線程已經獲取到鎖了
node.thread = null;
// 前一個節點已經沒有意義了
node.prev = null;
}
// 喚醒node節點的下一個非取消狀態的節點所在線程(即waitStatus<=0)
private void unparkSuccessor(Node node) {
// 獲取node節點的狀態
int ws = node.waitStatus;
// 如果小於0，就將狀態重新設置爲0，表示這個node節點已經完成了
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 下一個節點
Node s = node.next;
// 如果下一個節點爲null，或者狀態是已取消，那麼就要尋找下一個非取消狀態的節點
if (s == null || s.waitStatus > 0) {
// 先將s設置爲null，s不是非取消狀態的節點
s = null;
// 從隊列尾向前遍歷，直到遍歷到node節點
for (Node t = tail; t != null && t != node; t = t.prev)
// 因爲是從後向前遍歷，所以不斷覆蓋找到的值，這樣才能得到node節點後下一個非取消狀態的節點
if (t.waitStatus <= 0)
s = t;
}
// 如果s不爲null，表示存在非取消狀態的節點。那麼調用LockSupport.unpark方法，喚醒這個節點的線程
if (s != null)
LockSupport.unpark(s.thread);
}
// 會喚醒等待共享鎖的線程
private void doReleaseShared() {
for (;;) {
// 將同步隊列頭賦值給節點h
Node h = head;
// 如果節點h不爲null，且不等於同步隊列尾
if (h != null && h != tail) {
// 得到節點h的狀態
int ws = h.waitStatus;
// 如果狀態是Node.SIGNAL，就要喚醒節點h後繼節點的線程
if (ws == Node.SIGNAL) {
// 將節點h的狀態設置成0，如果設置失敗，就繼續循環，再試一次。
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
// 喚醒節點h後繼節點的線程
unparkSuccessor(h);
}
// 如果節點h的狀態是0，就設置ws的狀態是PROPAGATE。
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
// 如果同步隊列頭head節點發生改變，繼續循環，
// 如果沒有改變，就跳出循環
if (h == head)
break;
}
}
// 重新設置CLH隊列頭，如果CLH隊列頭的下一個節點爲null或者共享模式，
// 那麼就要喚醒共享鎖上等待的線程
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head;
// 設置新的同步隊列頭head
setHead(node);
// 如果propagate大於0，
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
// 獲取新的CLH隊列頭的下一個節點s
Node s = node.next;
// 如果節點s是空或者共享模式節點，那麼就要喚醒共享鎖上等待的線程
if (s == null || s.isShared())
doReleaseShared();
}
}
// 則將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了。
private void cancelAcquire(Node node) {
// 如果node爲null，就直接返回
if (node == null)
return;
//
node.thread = null;
// 跳過那些已取消的節點，在隊列中找到在node節點前面的第一次狀態不是已取消的節點
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// 記錄pred原來的下一個節點，用於CAS函數更新時使用
Node predNext = pred.next;
// Can use unconditional write instead of CAS here.
// After this atomic step, other Nodes can skip past us.
// Before, we are free of interference from other threads.
// 將node節點狀態設置爲已取消Node.CANCELLED;
node.waitStatus = Node.CANCELLED;
// 如果node節點是隊列尾節點，那麼就將pred節點設置爲新的隊列尾節點
if (node == tail && compareAndSetTail(node, pred)) {
// 並且設置pred節點的下一個節點next爲null
compareAndSetNext(pred, predNext, null);
} else {
// If successor needs signal, try to set pred's next-link
// so it will get one. Otherwise wake it up to propagate.
int ws;
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
/**
* 根據前一個節點pred的狀態，來判斷當前線程是否應該被阻塞
* @param pred : node節點的前一個節點
* @param node
* @return 返回true 表示當前線程應該被阻塞，之後應該會調用parkAndCheckInterrupt方法來阻塞當前線程
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
// 如果前一個pred的狀態是Node.SIGNAL，那麼直接返回true，當前線程應該被阻塞
return true;
if (ws > 0) {
// 如果前一個節點狀態是Node.CANCELLED(大於0就是CANCELLED)，
// 表示前一個節點所在線程已經被喚醒了，要從CLH隊列中移除CANCELLED的節點。
// 所以從pred節點一直向前查找直到找到不是CANCELLED狀態的節點，並把它賦值給node.prev，
// 表示node節點的前一個節點已經改變。
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 此時前一個節點pred的狀態只能是0或者PROPAGATE，不可能是CONDITION狀態
// CONDITION(這個是特殊狀態，只在condition列表中節點中存在，CLH隊列中不存在這個狀態的節點)
// 將前一個節點pred的狀態設置成Node.SIGNAL，這樣在下一次循環時，就是直接阻塞當前線程
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
/**
* 當前線程發出中斷通知
*/
static void selfInterrupt() {
Thread.currentThread().interrupt();
}
/**
* 阻塞當前線程，線程被喚醒後返回當前線程中斷狀態
*/
private final boolean parkAndCheckInterrupt() {
// 通過LockSupport.park方法，阻塞當前線程
LockSupport.park(this);
// 當前線程被喚醒後，返回當前線程中斷狀態
return Thread.interrupted();
}
/**
* 想要獲取鎖的 acquire系列方法，都會這個方法來獲取鎖
* 循環通過tryAcquire方法不斷去獲取鎖，如果沒有獲取成功，就有可能調用parkAndCheckInterrupt方法，讓當前線程阻塞
* @param node 想要獲取鎖的節點
* @param arg
* @return 返回true，表示在線程等待的過程中，線程被中斷了
*/
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
// 表示線程在等待過程中，是否被中斷了
boolean interrupted = false;
// 通過死循環，直到node節點的線程獲取到鎖，才返回
for (;;) {
// 獲取node的前一個節點
final Node p = node.predecessor();
// 如果前一個節點是隊列頭head，並且嘗試獲取鎖成功
// 那麼當前線程就不需要阻塞等待，繼續執行
if (p == head && tryAcquire(arg)) {
// 將節點node設置爲新的隊列頭
setHead(node);
// help GC
p.next = null;
// 不需要調用cancelAcquire方法
failed = false;
return interrupted;
}
// 當p節點的狀態是Node.SIGNAL時，就會調用parkAndCheckInterrupt方法，阻塞node線程
// node線程被阻塞，有兩種方式喚醒，
// 1.是在unparkSuccessor(Node node)方法，會喚醒被阻塞的node線程，返回false
// 2.node線程被調用了interrupt方法，線程被喚醒，返回true
// 在這裏只是簡單地將interrupted = true，沒有跳出for的死循環，繼續嘗試獲取鎖
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
// failed爲true，表示發生異常，
// 則將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了。
if (failed)
cancelAcquire(node);
}
}
/**
* 這個方法與acquireQueued(final Node node, int arg)方法流程幾乎一樣
* 只不過當parkAndCheckInterrupt返回true時，直接拋出異常。
* @param arg
* @throws InterruptedException
*/
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
// 爲當前線程創建節點node，並插入到隊列中
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
// 通過死循環，直到node節點的線程獲取到鎖，或者當前線程有中斷請求會拋出中斷異常
for (;;) {
final Node p = node.predecessor();
// 如果前一個節點是隊列頭head，並且嘗試獲取鎖成功
// 將該節點node設置成隊列頭head
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return;
}
// 當p節點的狀態是Node.SIGNAL時，就會調用parkAndCheckInterrupt方法，阻塞node線程
// node線程被阻塞，有兩種方式喚醒，
// 1.是在unparkSuccessor(Node node)方法，會喚醒被阻塞的node線程，返回false
// 2.node線程被調用了interrupt方法，線程被喚醒，返回true
// 在這裏如果parkAndCheckInterrupt返回true，就會拋出InterruptedException異常
// 跳出死循環，方法返回
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
/**
* 嘗試在一定的時間nanosTimeout內獲取鎖，超時了就返回false
*
*/
private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
// 計算截止時間
final long deadline = System.nanoTime() + nanosTimeout;
// 爲當前線程創建節點node，並插入到隊列中
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
// 如果前一個節點是隊列頭head，並且嘗試獲取鎖成功
// 將該節點node設置成隊列頭head
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
// 計算剩餘時間
nanosTimeout = deadline - System.nanoTime();
// 剩餘時間小於等於0，就直接返回false，獲取鎖失敗
if (nanosTimeout <= 0L)
return false;
// 當p節點的狀態是Node.SIGNAL時，調用LockSupport.parkNanos阻塞當前線程
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
// 當前線程阻塞nanosTimeout時間
LockSupport.parkNanos(this, nanosTimeout);
// 如果當前線程中斷標誌位是true，拋出InterruptedException異常
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
// failed爲true，表示發生異常，
// 則將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了
if (failed)
cancelAcquire(node);
}
}
/**
* 獲取共享鎖，獲取失敗，則會阻塞當前線程，直到獲取共享鎖返回
* @param arg the acquire argument
*/
private void doAcquireShared(int arg) {
// 爲當前線程創建共享鎖節點node
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
// 如果節點node前一個節點是同步隊列頭節點。就會調用tryAcquireShared方法嘗試獲取共享鎖
if (p == head) {
int r = tryAcquireShared(arg);
// 如果返回值大於0，表示獲取共享鎖成功
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
// 如果節點p的狀態是Node.SIGNAL，就是調用parkAndCheckInterrupt方法阻塞當前線程
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
// failed爲true，表示發生異常，
// 則將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了
if (failed)
cancelAcquire(node);
}
}
/**
* Acquires in shared interruptible mode.
* @param arg the acquire argument
*/
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
// failed爲true，表示發生異常，
// 則將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了
if (failed)
cancelAcquire(node);
}
}
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return true;
}
}
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
// Main exported methods
// 嘗試去獲取獨佔鎖，立即返回。如果返回true表示獲取鎖成功。
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
// 嘗試去釋放當前線程持有的獨佔鎖，立即返回。如果返回true表示釋放鎖成功
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
// 嘗試去獲取共享鎖，立即返回。返回值大於等於0，表示獲取共享鎖成功
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
// 嘗試去釋放共享鎖
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}
/**
* 獲取獨佔鎖。如果沒有獲取到，線程就會阻塞等待，直到獲取鎖。不會響應中斷異常
* @param arg
*/
public final void acquire(int arg) {
// 1. 先調用tryAcquire方法，嘗試獲取獨佔鎖，返回true，表示獲取到鎖，不需要執行acquireQueued方法。
// 2. 調用acquireQueued方法，先調用addWaiter方法爲當前線程創建一個節點node，並插入隊列中，
// 然後調用acquireQueued方法去獲取鎖，如果不成功，就會讓當前線程阻塞，當鎖釋放時纔會被喚醒。
// acquireQueued方法返回值表示在線程等待過程中，是否有另一個線程調用該線程的interrupt方法，發起中斷。
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// public final void acquire(int arg) {
// // 1.先調用tryAcquire方法，嘗試獲取獨佔鎖，返回true則直接返回
// if (tryAcquire(arg)) return;
// // 2. 調用addWaiter方法爲當前線程創建一個節點node，並插入隊列中
// Node node = addWaiter(Node.EXCLUSIVE);
// // 調用acquireQueued方法去獲取鎖，
// // acquireQueued方法返回值表示在線程等待過程中，是否有另一個線程調用該線程的interrupt方法，發起中斷。
// boolean interrupted = acquireQueued(node, arg);
// // 如果interrupted爲true，則當前線程要發起中斷請求
// if (interrupted) {
// selfInterrupt();
// }
// }
/**
* 獲取獨佔鎖。如果沒有獲取到，線程就會阻塞等待，直到獲取鎖。如果有中斷請求就會產生中斷異常
* @param arg
*/
public final void acquireInterruptibly(int arg)
throws InterruptedException {
// 如果當前線程中斷標誌位是true，那麼直接拋出中斷異常
if (Thread.interrupted())
throw new InterruptedException();
// 先調用tryAcquire方法，嘗試獲取獨佔鎖，返回true，表示獲取到鎖，不需要執行doAcquireInterruptibly方法。
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}
/**
* 嘗試在一定時間內獲取獨佔鎖。如果有中斷請求就會產生中斷異常。
* 返回true，表示獲取鎖成功
*/
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 如果當前線程中斷標誌位是true，那麼直接拋出中斷異常
if (Thread.interrupted())
throw new InterruptedException();
// 先調用tryAcquire方法，嘗試獲取獨佔鎖，返回true，表示獲取到鎖。
// 否則調用doAcquireNanos方法獲取鎖
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout);
}
// 在獨佔鎖模式下，釋放鎖的操作
public final boolean release(int arg) {
// 調用tryRelease方法，嘗試去釋放鎖，由子類具體實現
if (tryRelease(arg)) {
Node h = head;
// 如果隊列頭節點的狀態不是0，那麼隊列中就可能存在需要喚醒的等待節點。
// 還記得我們在acquireQueued(final Node node, int arg)獲取鎖的方法中，如果節點node沒有獲取到鎖，
// 那麼我們會將節點node的前一個節點狀態設置爲Node.SIGNAL，然後調用parkAndCheckInterrupt方法
// 將節點node所在線程阻塞。
// 在這裏就是通過unparkSuccessor方法，進而調用LockSupport.unpark(s.thread)方法，喚醒被阻塞的線程
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
// 獲取共享鎖
public final void acquireShared(int arg) {
// 嘗試去獲取共享鎖，如果返回值小於0表示獲取共享鎖失敗
if (tryAcquireShared(arg) < 0)
// 調用doAcquireShared方法去獲取共享鎖
doAcquireShared(arg);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
return tryAcquireShared(arg) >= 0 ||
doAcquireSharedNanos(arg, nanosTimeout);
}
// 釋放共享鎖
public final boolean releaseShared(int arg) {
// 嘗試釋放共享鎖
if (tryReleaseShared(arg)) {
// 喚醒等待共享鎖的線程
doReleaseShared();
return true;
}
return false;
}
// Queue inspection methods
public final boolean hasQueuedThreads() {
return head != tail;
}
public final boolean hasContended() {
return head != null;
}
public final Thread getFirstQueuedThread() {
// handle only fast path, else relay
return (head == tail) ? null : fullGetFirstQueuedThread();
}
/**
* Version of getFirstQueuedThread called when fastpath fails
*/
private Thread fullGetFirstQueuedThread() {
Node h, s;
Thread st;
if (((h = head) != null && (s = h.next) != null &&
s.prev == head && (st = s.thread) != null) ||
((h = head) != null && (s = h.next) != null &&
s.prev == head && (st = s.thread) != null))
return st;
Node t = tail;
Thread firstThread = null;
while (t != null && t != head) {
Thread tt = t.thread;
if (tt != null)
firstThread = tt;
t = t.prev;
}
return firstThread;
}
public final boolean isQueued(Thread thread) {
if (thread == null)
throw new NullPointerException();
for (Node p = tail; p != null; p = p.prev)
if (p.thread == thread)
return true;
return false;
}
final boolean apparentlyFirstQueuedIsExclusive() {
Node h, s;
return (h = head) != null &&
(s = h.next) != null &&
!s.isShared() &&
s.thread != null;
}
// 返回false表示隊列爲null，或者當前線程節點在是隊列頭的下一個節點。
// 返回true表示有一個線程節點在當前線程節點之前
public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
// Instrumentation and monitoring methods
public final int getQueueLength() {
int n = 0;
for (Node p = tail; p != null; p = p.prev) {
if (p.thread != null)
++n;
}
return n;
}
public final Collection<Thread> getQueuedThreads() {
ArrayList<Thread> list = new ArrayList<Thread>();
for (Node p = tail; p != null; p = p.prev) {
Thread t = p.thread;
if (t != null)
list.add(t);
}
return list;
}
public final Collection<Thread> getExclusiveQueuedThreads() {
ArrayList<Thread> list = new ArrayList<Thread>();
for (Node p = tail; p != null; p = p.prev) {
if (!p.isShared()) {
Thread t = p.thread;
if (t != null)
list.add(t);
}
}
return list;
}
public final Collection<Thread> getSharedQueuedThreads() {
ArrayList<Thread> list = new ArrayList<Thread>();
for (Node p = tail; p != null; p = p.prev) {
if (p.isShared()) {
Thread t = p.thread;
if (t != null)
list.add(t);
}
}
return list;
}
public String toString() {
int s = getState();
String q = hasQueuedThreads() ? "non" : "";
return super.toString() +
"[State = " + s + ", " + q + "empty queue]";
}
// Internal support methods for Conditions
// 節點node是不是在CLH隊列中
final boolean isOnSyncQueue(Node node) {
// 如果node的狀態是Node.CONDITION，或者node沒有前一個節點prev，
// 那麼返回false，節點node不在同步隊列中
if (node.waitStatus == Node.CONDITION || node.prev == null)
return false;
// 如果node有下一個節點next，那麼它一定在同步隊列中
if (node.next != null) // If has successor, it must be on queue
return true;
// 從同步隊列中查找節點node
return findNodeFromTail(node);
}
// 在同步隊列中從後向前查找節點node，如果找到返回true，否則返回false
private boolean findNodeFromTail(Node node) {
Node t = tail;
for (;;) {
if (t == node)
return true;
if (t == null)
return false;
t = t.prev;
}
}
// 返回true表示節點node插入到同步隊列中，返回false表示節點node沒有插入到同步隊列中
final boolean transferForSignal(Node node) {
// 如果節點node的狀態不是Node.CONDITION，或者更新狀態失敗，
// 說明該node節點已經插入到同步隊列中，所以直接返回false
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
// 將節點node插入到同步隊列中，p是原先同步隊列尾節點，也是node節點的前一個節點
Node p = enq(node);
int ws = p.waitStatus;
// 如果前一個節點是已取消狀態，或者不能將它設置成Node.SIGNAL狀態。
// 就說明節點p之後也不會發起喚醒下一個node節點線程的操作，
// 所以這裏直接調用 LockSupport.unpark(node.thread)方法，喚醒節點node所在線程
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true;
}
// 等待節點node存放到同步隊列中，如果是當前線程插入的，返回true，如果是另一個線程插入的，返回false。
final boolean transferAfterCancelledWait(Node node) {
// 當節點node狀態還是Node.CONDITION，改變它的狀態是0，然後插入到同步隊列中。
if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
enq(node);
return true;
}
// 如果節點node不在同步隊列中，當前線程讓出執行權
while (!isOnSyncQueue(node))
Thread.yield();
return false;
}
/**
* 釋放當前線程佔有的鎖，並喚醒CLH隊列一個等待線程
* 如果失敗就拋出異常，設置node節點的狀態是Node.CANCELLED
* @return
*/
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;
}
}
// Instrumentation methods for conditions
public final boolean owns(ConditionObject condition) {
return condition.isOwnedBy(this);
}
public final boolean hasWaiters(ConditionObject condition) {
if (!owns(condition))
throw new IllegalArgumentException("Not owner");
return condition.hasWaiters();
}
public final int getWaitQueueLength(ConditionObject condition) {
if (!owns(condition))
throw new IllegalArgumentException("Not owner");
return condition.getWaitQueueLength();
}
public final Collection<Thread> getWaitingThreads(ConditionObject condition) {
if (!owns(condition))
throw new IllegalArgumentException("Not owner");
return condition.getWaitingThreads();
}
public class ConditionObject implements Condition, java.io.Serializable {
private static final long serialVersionUID = 1173984872572414699L;
/** Condition隊列頭. */
private transient Node firstWaiter;
/** Condition隊列尾. */
private transient Node lastWaiter;
/**
* Creates a new {@code ConditionObject} instance.
*/
public ConditionObject() { }
// Internal methods
/**
* 爲當前線程創建新的Node節點，並且將這個節點插入到Condition隊列中了
* @return its new wait node
*/
private Node addConditionWaiter() {
Node t = lastWaiter;
// 如果Condition隊列尾節點的狀態不是Node.CONDITION
if (t != null && t.waitStatus != Node.CONDITION) {
// 清除Condition隊列中，狀態不是Node.CONDITION的節點，
// 並且可能會重新設置firstWaiter和lastWaiter
unlinkCancelledWaiters();
// 重新將Condition隊列尾賦值給t
t = lastWaiter;
}
// 爲當前線程創建一個狀態爲Node.CONDITION的節點
Node node = new Node(Thread.currentThread(), Node.CONDITION);
// 如果t爲null，表示Condition隊列爲空，將node節點賦值給鏈表頭
if (t == null)
firstWaiter = node;
else
// 將新節點node插入到Condition隊列尾
t.nextWaiter = node;
// 將新節點node設置爲新的Condition隊列尾
lastWaiter = node;
return node;
}
// 將Condition隊列中的first節點插入到CLH隊列中
private void doSignal(Node first) {
do {
// 原先的Condition隊列頭節點取消，所以重新賦值Condition隊列頭節點
// 如果新的Condition隊列頭節點爲null，表示Condition隊列爲空了
// ，所以也要設置Condition隊列尾lastWaiter爲null
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
// 取消first節點nextWaiter引用
first.nextWaiter = null;
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
/**
* 將condition隊列中所有的節點都插入到同步隊列中
* @param first condition隊列頭節點
*/
private void doSignalAll(Node first) {
// 表示將condition隊列設置爲空
lastWaiter = firstWaiter = null;
do {
// 得到condition隊列的下一個節點
Node next = first.nextWaiter;
first.nextWaiter = null;
// 將節點first插入到同步隊列中
transferForSignal(first);
first = next;
// 循環遍歷condition隊列中所有的節點
} while (first != null);
}
// 清除Condition隊列中狀態不是Node.CONDITION的節點
private void unlinkCancelledWaiters() {
// condition隊列頭賦值給t
Node t = firstWaiter;
// 這個trail節點，只是起輔助作用
Node trail = null;
while (t != null) {
//得到下一個節點next。當節點是condition時候，nextWaiter表示condition隊列的下一個節點
Node next = t.nextWaiter;
// 如果節點t的狀態不是CONDITION，那麼該節點就要從condition隊列中移除
if (t.waitStatus != Node.CONDITION) {
// 將節點t的nextWaiter設置爲null
t.nextWaiter = null;
// 如果trail爲null，表示原先的condition隊列頭節點實效，需要設置新的condition隊列頭
if (trail == null)
firstWaiter = next;
else
// 將節點t從condition隊列中移除，因爲改變了引用的指向，從condition隊列中已經找不到節點t了
trail.nextWaiter = next;
// 如果next爲null，表示原先的condition隊列尾節點也實效，重新設置隊列尾節點
if (next == null)
lastWaiter = trail;
}
else
// 遍歷到的有效節點
trail = t;
// 將next賦值給t，遍歷完整個condition隊列
t = next;
}
}
// public methods
// 如果condition隊列不爲空，將condition隊列頭節點插入到同步隊列中
public final void signal() {
// 如果當前線程不是獨佔鎖線程，就拋出IllegalMonitorStateException異常
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 將Condition隊列頭賦值給節點first
Node first = firstWaiter;
if (first != null)
// 將Condition隊列中的first節點插入到CLH隊列中
doSignal(first);
}
// 將condition隊列中所有的節點都插入到同步隊列中
public final void signalAll() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
if (first != null)
doSignalAll(first);
}
// 讓當前持有鎖的線程阻塞等待，並釋放鎖。如果線程等待期間發出中斷請求，不會產生中斷異常
public final void awaitUninterruptibly() {
// 爲當前線程創建新的Node節點，並且將這個節點插入到Condition隊列中了
Node node = addConditionWaiter();
// 釋放當前線程佔有的鎖，並喚醒其他線程
int savedState = fullyRelease(node);
boolean interrupted = false;
// 如果節點node不在同步隊列中(注意不是Condition隊列)，就阻塞當前線程
while (!isOnSyncQueue(node)) {
// 阻塞當前線程
LockSupport.park(this);
if (Thread.interrupted())
interrupted = true;
}
// 如果節點node已經在同步隊列中了，獲取同步鎖，只有得到鎖才能繼續執行，否則線程繼續阻塞等待
if (acquireQueued(node, savedState) || interrupted)
selfInterrupt();
}
/** Mode meaning to reinterrupt on exit from wait */
private static final int REINTERRUPT = 1;
/** Mode meaning to throw InterruptedException on exit from wait */
private static final int THROW_IE = -1;
/**
* 如果線程沒有發起了中斷請求，返回0.
* 如果線程發起了中斷請求，且中斷請求在signalled(即調用signal或signalAll)之前返回THROW_IE
* 中斷請求在signalled之後返回REINTERRUPT
*/
private int checkInterruptWhileWaiting(Node node) {
return Thread.interrupted() ?
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
0;
}
/**
* 如果interruptMode是THROW_IE，就拋出InterruptedException異常
* 如果interruptMode是REINTERRUPT，則當前線程再發出中斷請求
* 否則就什麼都不做
*/
private void reportInterruptAfterWait(int interruptMode)
throws InterruptedException {
if (interruptMode == THROW_IE)
throw new InterruptedException();
else if (interruptMode == REINTERRUPT)
selfInterrupt();
}
/**
* 讓當前持有鎖的線程阻塞等待，並釋放鎖。如果有中斷請求，則拋出InterruptedException異常
* @throws InterruptedException
*/
public final void await() throws InterruptedException {
// 如果當前線程中斷標誌位是true，就拋出InterruptedException異常
if (Thread.interrupted())
throw new InterruptedException();
// 爲當前線程創建新的Node節點，並且將這個節點插入到Condition隊列中了
Node node = addConditionWaiter();
// 釋放當前線程佔有的鎖，並喚醒CLH隊列一個等待線程
int savedState = fullyRelease(node);
int interruptMode = 0;
// 如果節點node不在同步隊列中(注意不是Condition隊列)
while (!isOnSyncQueue(node)) {
// 阻塞當前線程,那麼怎麼喚醒這個線程呢？
// 首先我們必須調用signal或者signalAll將這個節點node加入到同步隊列。
// 只有這樣unparkSuccessor(Node node)方法，纔有可能喚醒被阻塞的線程
LockSupport.park(this);
// 如果當前線程產生中斷請求，就跳出循環
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 如果節點node已經在同步隊列中了，獲取同步鎖，只有得到鎖才能繼續執行，否則線程繼續阻塞等待
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 清除Condition隊列中狀態不是Node.CONDITION的節點
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 = addConditionWaiter();
int savedState = fullyRelease(node);
final long deadline = System.nanoTime() + nanosTimeout;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
transferAfterCancelledWait(node);
break;
}
if (nanosTimeout >= spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return deadline - System.nanoTime();
}
public final boolean awaitUntil(Date deadline)
throws InterruptedException {
long abstime = deadline.getTime();
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (System.currentTimeMillis() > abstime) {
timedout = transferAfterCancelledWait(node);
break;
}
LockSupport.parkUntil(this, abstime);
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);
return !timedout;
}
public final boolean await(long time, TimeUnit unit)
throws InterruptedException {
long nanosTimeout = unit.toNanos(time);
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
final long deadline = System.nanoTime() + nanosTimeout;
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
timedout = transferAfterCancelledWait(node);
break;
}
if (nanosTimeout >= spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
nanosTimeout = deadline - System.nanoTime();
}
// 獲取
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 清除Condition隊列中狀態不是Node.CONDITION的節點
if (node.nextWaiter != null)
unlinkCancelledWaiters();
// 是否要拋出異常，或者發出中斷請求
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return !timedout;
}
/**
* 返回true：表示這個condition對象是由sync對象創建的。
*/
final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {
return sync == AbstractQueuedSynchronizer.this;
}
/**
* 這個condition對象上是否有等待線程，即condition隊列不爲空，且有一個節點的狀態是 Node.CONDITION
*/
protected final boolean hasWaiters() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
// 遍歷condition隊列
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
if (w.waitStatus == Node.CONDITION)
return true;
}
return false;
}
/**
* 返回condition對象上等待線程的個數，即遍歷condition隊列，計算節點的狀態是Node.CONDITION的個數
*/
protected final int getWaitQueueLength() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int n = 0;
// 遍歷condition隊列
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
// 計算節點的狀態是Node.CONDITION的個數
if (w.waitStatus == Node.CONDITION)
++n;
}
return n;
}
/**
* 返回condition對象上等待線程的集合。
*/
protected final Collection<Thread> getWaitingThreads() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
ArrayList<Thread> list = new ArrayList<Thread>();
// 遍歷condition隊列
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
// 當節點的狀態是Node.CONDITION，將節點的線程添加到list集合中
if (w.waitStatus == Node.CONDITION) {
Thread t = w.thread;
if (t != null)
list.add(t);
}
}
return list;
}
}
// 支持compareAndSet操作
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;
static {
try {
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
headOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
tailOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
waitStatusOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("waitStatus"));
nextOffset = unsafe.objectFieldOffset
(Node.class.getDeclaredField("next"));
} catch (Exception ex) { throw new Error(ex); }
}
/**
* 通過CAS函數設置head值，僅僅在enq方法中調用
*/
private final boolean compareAndSetHead(Node update) {
return unsafe.compareAndSwapObject(this, headOffset, null, update);
}
/**
* 通過CAS函數設置tail值，僅僅在enq方法中調用
*/
private final boolean compareAndSetTail(Node expect, Node update) {
return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
/**
* 通過CAS函數設置node對象的waitStatus值
*/
private static final boolean compareAndSetWaitStatus(Node node,
int expect,
int update) {
return unsafe.compareAndSwapInt(node, waitStatusOffset,
expect, update);
}
/**
* 通過CAS函數設置node對象的next值
*/
private static final boolean compareAndSetNext(Node node,
Node expect,
Node update) {
return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
}
}
對很少部分做整理，自己梳理一遍代碼思路更加清晰，膜拜原作者！侵刪！
本文參考：https://www.jianshu.com/p/0da2939391cf