JUC中的AQS底層詳細超詳解

private volatile int state;
protected final int getState() {
 return state;
}
protected final void setState(int newState) {
    state = newState;
}
// cas方法
compareAndSetState(int oldState, int newState);

 private Node enq(final Node node) {
 //多次嘗試，直到成功為止
 for (;;) {
 Node t = tail;
 //tail不存在，設定為首節點
 if (t == null) {
 if (compareAndSetHead(new Node()))
                    tail = head;
 } else {
 //設定為尾節點
 node.prev = t;
 if (compareAndSetTail(t, node)) {
 t.next = node;
 return t;
 }
 }
 }
 }

public final void acquire(int arg) {
 if (!tryAcquire(arg) &&
 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
 // 發現中斷過，則觸發中斷異常
 selfInterrupt();
}

protected final boolean tryAcquire(int acquires){
 final Thread current = Thread.currentThread();
 int c = getState();
 // state==0代表當前沒有鎖，可以進行獲取
 if (c == 0) {
 // 非公平才有的判斷，會判斷是否還有前驅節點，直接自己為頭節點了或者同步佇列空了才會繼續後面的鎖的獲取操作
 if (!hasQueuedPredecessors() 
 //CAS設定state為acquires，成功後標記exclusiveOwnerThread為當前執行緒
 && 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");
 // 因為是重入操作，可以直接進行state的增加，所以不需要CAS
 setState(nextc);
 return true;
 }
 return false;
}

 private Node addWaiter(Node mode) {
 Node node = new Node(Thread.currentThread(), mode);
 // Try the fast path of enq; backup to full enq on failure
 Node pred = tail;
 if (pred != null) {
 node.prev = pred;
 // 通過CAS競爭隊尾
 if (compareAndSetTail(pred, node)) {
 pred.next = node;
 return node;
 }
 }
 // 競爭隊尾失敗，於是進行CAS頻繁迴圈競爭隊尾
 enq(node);
 return node;
 }
 private Node enq(final Node node) {
 for (;;) {
 Node t = tail;
 if (t == null) { // Must initialize
 if (compareAndSetHead(new Node()))
                    tail = head;
 } else {
 node.prev = t;
 if (compareAndSetTail(t, node)) {
 t.next = node;
 return t;
 }
 }
 }
 }

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);
 // 說明前繼節點已經釋放掉資源了，將其next置空，好讓虛擬機器器提前回收掉前繼節點
 p.next = null; // help GC
 // 獲取資源成功，修改標記位
                failed = false;
 // 返回中斷標記
 return interrupted;
 }
 // 若前繼節點不是頭結點，或者獲取資源失敗，
 // 則需要判斷是否需要阻塞該節點持有的執行緒
 // 若可以阻塞，則繼續執行parkAndCheckInterrupt()函數，
 // 將該執行緒阻塞直至被喚醒
 // 喚醒後會檢查是否已經被中斷，若返回true，則將interrupted標誌置於true
 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                interrupted = true;
 }
 } finally {
 // 最終獲取資源失敗，則當前節點放棄獲取資源
 if (failed)
 cancelAcquire(node);
 }
 }

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
 // 獲取前繼節點的等待狀態
 int ws = pred.waitStatus;
 // 如果等待狀態為Node.SIGNAL(-1)，則直接返回true即可以阻塞
 // 因為這說明前繼節點完成資源的釋放或者中斷後，會主動喚醒後繼節點的（這也即是signal訊號的含義），因此方法外面不用再反覆CAS了，直接阻塞吧
 if (ws == Node.SIGNAL) return true;
 // 如果前繼節點的等待值大於0即CANCELLED（1）,說明前繼節點的執行緒發生過cancel動作
 // 那就繼續往前遍歷，直到當前節點的前繼節點的狀態不為cancel
 if (ws > 0) {
 do {
 node.prev = pred = pred.prev;
 } while (pred.waitStatus > 0);
 pred.next = node;
 } else {
 // 前繼節點的等待狀態不為SIGNAL(-1)，也不為Cancel(1)
 // 那麼只能是PROPAGATE(-3)或者CONDITION(-2)或者INITIAL（0）
 // 直接設定成SIGNAL，下一次還沒CAS成功，就直接睡覺了
 // 因此在前面所有節點沒辯護的情況下， 最多一次之後就會返回true讓外面阻塞
 compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
 }
 return false;
}

private final boolean parkAndCheckInterrupt() {
 LockSupport.park(this);
  // 確認是否是中斷導致的park結束，並清除中斷標記
 return Thread.interrupted();
}
public static void park(Object blocker) {
 Thread t = Thread.currentThread();
 setBlocker(t, blocker);
 UNSAFE.park(false, 0L);
 setBlocker(t, null);
}

reentrantLock.lock();
try {
 System.out.println("t1");
 TimeUnit.SECONDS.sleep(30);
} catch (InterruptedException e) {
 e.printStackTrace();
} finally {
 reentrantLock.unlock();
}

 public final boolean release(int arg) {
 // 是否釋放成功，tryRelease是子類要實現的方法
 if (tryRelease(arg)) {
 Node h = head;
 // 判斷頭節點是否正在阻塞中，是的話喚醒
 if (h != null && h.waitStatus != 0)
 // 喚醒頭節點
 unparkSuccessor(h);
 return true;
 }
 return false;
 }

 protected final boolean tryRelease(int releases) {
 int c = getState() - releases;
 if (Thread.currentThread() != getExclusiveOwnerThread())
 throw new IllegalMonitorStateException();
 boolean free = false;
 if (c == 0) {
                free = true;
 // 設定當前佔用執行緒為null
 setExclusiveOwnerThread(null);
 }
 // 不需要CAS，因為只有持有鎖的人才能做釋放，不擔心競爭
 setState(c);
 return free;
 }

static final class FairSync extends Sync {
 private static final long serialVersionUID = -3000897897090466540L;
 final void lock() {
 acquire(1);
 }

 Sync(int permits) {
 setState(permits);
 }

 protected int tryAcquireShared(int acquires) {
 for (;;) {
 // 隊頭判斷，公平鎖核心
 if (hasQueuedPredecessors())
 return -1;
 int available = getState();
 int remaining = available - acquires;
 // 號誌不足，直接返回負數
 if (remaining < 0 ||
 // 能搶成功，返回修改後的值，搶失敗則for迴圈繼續
 compareAndSetState(available, remaining))
 return remaining;
 }
 }

if (current == getExclusiveOwnerThread()) {
 int nextc = c + acquires;
 // 出現負數，說明溢位了
 if (nextc < 0) // 
 throw new Error("Maximum lock count exceeded");
 // 因為是重入操作，可以直接進行state的增加，所以不需要CAS
 setState(nextc);
 return true;
}

protected final boolean tryRelease(int releases) {
 int c = getState() - releases;
 if (Thread.currentThread() != getExclusiveOwnerThread())
 throw new IllegalMonitorStateException();
 boolean free = false;
 if (c == 0) {
 // 只有資源數為0才會解鎖
 // 才算釋放成功，否則這鎖還是佔住了
        free = true;
 setExclusiveOwnerThread(null);
 }
 setState(c);
 return free;
}