K60 Pro官方停產(chǎn) 第三方瞬間漲價
雖然沒有官方宣布，但Redmi的一些高管也已經(jīng)透露了，Redmi K60 Pro已經(jīng)停產(chǎn)且不會補貨，這一切都是為了即將到來的K60 Ultra鋪路，屬于廠家的正常操作。但有意思的是該機在停產(chǎn)之后
AQS 全稱 AbstractQueuedSynchronizer（抽象隊列同步器），旨在作為創(chuàng)建鎖和其他同步機制的基礎，常見的同步鎖 ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier等都是基于 AQS 實現(xiàn)的。所以只有了解了AQS的實現(xiàn)原理，才能更好學習使用其他同步鎖。
AQS的源碼邏輯比較復雜，很多開發(fā)者看見就頭疼，邏輯眾多，無法梳理清楚。原因就是開發(fā)者梳理源碼的步驟出錯了，剛開始就看AQS的加鎖、釋放鎖邏輯，陷入細節(jié)中不能自拔。正確的做法是，先整體后局部，先框架后細節(jié)。下面就帶著大家一下分析AQS源碼，保證清晰易懂。
為什么一上來先看AQS的加鎖流程，先要理解AQS的框架設計，才能去看具體的源碼。
問個問題，如果讓你設計一個同步鎖，你會怎么設計？
肯定先要梳理一下需求，需求沒有梳理清楚，就別談開發(fā)了。
我理解的設計一個同步鎖，需要滿足以下需求：
至此，我們梳理清楚了AQS的加鎖需求，而實際上AQS的加鎖流程跟上面的需求完全一致，下面用一張圖來表示。
圖片
看一下AQS內(nèi)部的架構設計和包含的屬性。
// AQS繼承自AbstractOwnableSynchronizer，為了記錄哪個線程占用鎖public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer { // 同步狀態(tài)，0表示無鎖，每次加鎖+1，釋放鎖-1 private volatile int state; // 同步隊列的頭尾節(jié)點 private transient volatile Node head; private transient volatile Node tail; // Node節(jié)點，用來包裝線程，放到隊列中 static final class Node { // 節(jié)點中的線程 volatile Thread thread; // 節(jié)點狀態(tài) volatile int waitStatus; // 同步隊列的前驅(qū)節(jié)點和后繼節(jié)點 volatile Node prev; volatile Node next; // 條件隊列的后繼節(jié)點或者同步隊列的共享/排他模式 Node nextWaiter; } // 條件隊列 public class ConditionObject implements Condition { // 條件隊列的頭尾節(jié)點 private transient Node firstWaiter; private transient Node lastWaiter; }}首先AQS繼承自AbstractOwnableSynchronizer，其實是為了記錄哪個線程正在占用鎖。
public abstract class AbstractOwnableSynchronizer { // 正在占用鎖的線程 private transient Thread exclusiveOwnerThread; // 設置占用鎖的線程 protected final void setExclusiveOwnerThread(Thread thread) { exclusiveOwnerThread = thread; } protected final Thread getExclusiveOwnerThread() { return exclusiveOwnerThread; }}無論是同步隊列還是條件隊列中線程都需要包裝成Node節(jié)點。
圖片
同步隊列：是帶有頭尾節(jié)點的雙鏈表，由Node節(jié)點組成，使用prev和next組成雙向鏈表，nextWaiter只用來表示是共享模式還是排他模式。條件隊列：是帶有頭尾節(jié)點的單鏈表。同樣由Node節(jié)點組成，沒有使用到Node中prev和next屬性，而是使用nextWaiter組成單鏈表。 這個復用對象的設計思想值得我們學習。 同步隊列head節(jié)點是個啞節(jié)點，里面并沒有存儲線程對象。當然head節(jié)點也可以看成是給當前持有鎖的線程使用的。 Node節(jié)點的節(jié)點狀態(tài)（waitStatus）共有5種：
節(jié)點狀態(tài)（waitStatus）流轉過程如下：
圖片
AQS支持排他模式和共享模式兩種訪問資源的模式（排他模式又叫獨占模式）。 排他模式的方法：
// 加鎖acquire(int arg);// 加可中斷的鎖acquireInterruptibly(int arg);// 加鎖，帶超時時間（如果指定時間內(nèi)加鎖不成功，就返回false）tryAcquireNanos(int arg, long nanosTimeout);// 釋放鎖release(int arg);共享模式的方法：
// 加鎖acquireShared(int arg);// 加可中斷的鎖acquireSharedInterruptibly(int arg);// 加鎖，帶超時時間（如果指定時間內(nèi)加鎖不成功，就返回false）tryAcquireSharedNanos(int arg, long nanosTimeout);// 釋放鎖releaseShared(int arg);排他模式和共享模式的方法并沒有實現(xiàn)具體的加鎖、釋放鎖邏輯，AQS中只是定義了加鎖、釋放鎖的抽象方法。 留給子類實現(xiàn)的抽象方法：
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable { // 加排他鎖 protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); } // 釋放排他鎖 protected boolean tryRelease(int arg) { throw new UnsupportedOperationException(); } // 加共享鎖 protected int tryAcquireShared(int arg) { throw new UnsupportedOperationException(); } // 釋放共享鎖 protected boolean tryReleaseShared(int arg) { throw new UnsupportedOperationException(); } // 判斷是否是當前線程正在持有鎖 protected boolean isHeldExclusively() { throw new UnsupportedOperationException(); }}這里就用到了設計模式中的模板模式，父類AQS定義了加鎖、釋放鎖的流程，子類ReentrantLock、CountDownLatch、Semaphore、CyclicBarrier負責實現(xiàn)具體的加鎖、釋放鎖邏輯。 這不是個面試知識點嗎？ 面試官再問你，你看過哪些框架源碼使用到了設計模式？ 你就可以回答AQS源碼中用到了模板模式，巴拉巴拉，妥妥的加分項！
條件隊列中常用的方法如下：
// 等待方法，并釋放鎖public final void await() throws InterruptedException { ……}// 等待指定時間public final boolean await(long time, TimeUnit unit) throws InterruptedException { ……}// 喚醒條件隊列中的單個線程public final void signal() { ……}// 喚醒條件隊列中的所有線程public final void signalAll() { ……}整個加鎖流程如下：
圖片
再看一下加鎖方法的源碼：
// 加鎖方法，傳參是1，表示加鎖一次public final void acquire(int arg) { // 1. 首先嘗試獲取鎖，如果獲取成功，則設置state+1，exclusiveOwnerThread=currentThread（留給子類實現(xiàn)） if (!tryAcquire(arg) && // 2. 如果沒有獲取成功，把線程組裝成Node節(jié)點，追加到同步隊列末尾 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) { // 3. 加入同步隊列后，將自己掛起 selfInterrupt(); }}再看一下addWaiter()方法源碼，作用就是把線程組裝成Node節(jié)點，追加到同步隊列末尾。
// 追加到同步隊列末尾，傳參mode表示是共享模式or排他模式private Node addWaiter(Node mode) { // 1. 組裝成Node節(jié)點 Node node = new Node(Thread.currentThread(), mode); Node pred = tail; if (pred != null) { node.prev = pred; // 2. 在多線程競爭不激烈的情況下，通過CAS方法追加到同步隊列末尾 if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } // 3. 在多線程競爭激烈的情況下，使用死循環(huán)保證追加到同步隊列末尾 enq(node); return node;}// 通過死循環(huán)的方式，追加到同步隊列末尾private Node enq(final Node node) { for (; ; ) { Node t = tail; if (t == null) { // 如果同步隊列為空，先初始化頭節(jié)點（頭節(jié)點是空節(jié)點） if (compareAndSetHead(new Node())) tail = head; } else { // 再使用CAS追加到同步隊列末尾 node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } }}// 創(chuàng)建Node節(jié)點，傳參thread表示當前線程，mode表示共享模式or排他模式Node(Thread thread, Node mode) { this.thread = thread; this.nextWaiter = mode;}再看一下addWaiter()方法外層的acquireQueued()方法，作用就是：
// 追加到同步隊列末尾后，再次嘗試獲取鎖final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; for (; ; ) { // 1. 找到前驅(qū)節(jié)點 final Node p = node.predecessor(); // 2. 如果前驅(qū)節(jié)點是頭結點，就再次嘗試獲取鎖 if (p == head && tryAcquire(arg)) { // 3. 獲取鎖成功后，把自己設置為頭節(jié)點 setHead(node); p.next = null; failed = false; return interrupted; } // 4. 如果還是沒有獲取到鎖，找到可以將自己喚醒的節(jié)點 if (shouldParkAfterFailedAcquire(p, node) && // 5. 最后才放心地將自己掛起 parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); }}再看一下shouldParkAfterFailedAcquire()方法，是怎么找到將自己喚醒的節(jié)點的？為什么要找這個節(jié)點？
// 加入同步隊列后，找到能將自己喚醒的節(jié)點private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { int ws = pred.waitStatus; // 1. 如果前驅(qū)節(jié)點的狀態(tài)已經(jīng)是SIGNAL狀態(tài)（釋放鎖后，需要喚醒后繼節(jié)點），就無需操作了 if (ws == Node.SIGNAL) return true; // 2. 如果前驅(qū)節(jié)點的狀態(tài)是已取消，就繼續(xù)向前遍歷 if (ws > 0) { do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { // 3. 找到了不是取消狀態(tài)的節(jié)點，把該節(jié)點狀態(tài)設置成SIGNAL compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false;}從代碼中可以很清楚的看到，目的就是為了找到不是取消狀態(tài)的節(jié)點，并把該節(jié)點的狀態(tài)設置成SIGNAL。 狀態(tài)是SIGNAL的節(jié)點，釋放鎖后，需要喚醒其后繼節(jié)點。 簡單理解就是：小弟初來乍到，特意來知會老大一聲，有好事，多通知小弟。 再看一下釋放鎖的邏輯。
釋放鎖的流程如下：
圖片
釋放鎖的代碼邏輯比較簡單：
// 釋放鎖，傳參是1，表示釋放鎖一次public final boolean release(int arg) { // 1. 先嘗試釋放鎖，如果成功，則設置state-1，exclusiveOwnerThread=null（由子類實現(xiàn)） if (tryRelease(arg)) { Node h = head; // 2. 如果同步隊列中還有其他節(jié)點，就喚醒下一個節(jié)點 if (h != null && h.waitStatus != 0) // 3. 喚醒其后繼節(jié)點 unparkSuccessor(h); return true; } return false;}再看一下喚醒后繼節(jié)點的方法，作用就是重置頭節(jié)點狀態(tài)，然后找到一個有效的后繼節(jié)點并喚醒。
// 喚醒后繼節(jié)點private void unparkSuccessor(Node node) { int ws = node.waitStatus; // 1. 如果頭節(jié)點不是取消狀態(tài)，就重置成初始狀態(tài) if (ws < 0) compareAndSetWaitStatus(node, ws, 0); Node s = node.next; // 2. 如果后繼節(jié)點是null或者是取消狀態(tài) if (s == null || s.waitStatus > 0) { s = null; // 3. 從隊尾開始遍歷，找到一個有效狀態(tài)的節(jié)點 for (Node t = tail; t != null && t != node; t = t.prev) if (t.waitStatus <= 0) s = t; } // 3. 喚醒這個有效節(jié)點 if (s != null) LockSupport.unpark(s.thread);}await等待的流程：
圖片
持有鎖的線程可以調(diào)用await()方法，在ConditionObject類里面。作用是：釋放鎖，并追加到條件隊列末尾。
// 等待方法public final void await() throws InterruptedException { // 如果線程已中斷，則拋出中斷異常 if (Thread.interrupted()) throw new InterruptedException(); // 1. 追加到條件隊列末尾 Node node = addConditionWaiter(); // 2. 釋放鎖 int savedState = fullyRelease(node); int interruptMode = 0; // 3. 有可能剛加入條件隊列就被轉移到同步隊列了，如果還在條件隊列，就可以放心地掛起自己 while (!isOnSyncQueue(node)) { LockSupport.park(this); if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; } // 4. 如果已經(jīng)轉移到同步隊列，就嘗試獲取鎖 if (acquireQueued(node, savedState) && interruptMode != THROW_IE) interruptMode = REINTERRUPT; if (node.nextWaiter != null) // 5. 清除條件隊列中已取消的節(jié)點 unlinkCancelledWaiters(); if (interruptMode != 0) reportInterruptAfterWait(interruptMode);}再看一下addConditionWaiter方法，是怎么追加到條件隊列末尾的？
// 追加到條件隊列末尾private Node addConditionWaiter() { Node t = lastWaiter; // 1. 清除已取消的節(jié)點，找到有效節(jié)點 if (t != null && t.waitStatus != Node.CONDITION) { unlinkCancelledWaiters(); t = lastWaiter; } // 2. 創(chuàng)建Node節(jié)點，狀態(tài)是CONDITION（表示處于條件隊列） Node node = new Node(Thread.currentThread(), Node.CONDITION); // 3. 追加到條件隊列末尾 if (t == null) firstWaiter = node; else t.nextWaiter = node; lastWaiter = node; return node;}signal喚醒的流程：
圖片
// 喚醒條件隊列的頭節(jié)點public final void signal() { // 1. 只有持有鎖的線程才能調(diào)用signal方法 if (!isHeldExclusively()) throw new IllegalMonitorStateException(); // 2. 找到條件隊列的頭節(jié)點 Node first = firstWaiter; if (first != null) // 3. 開始喚醒 doSignal(first);}// 實際的喚醒方法private void doSignal(Node first) { do { // 4. 從條件隊列中移除頭節(jié)點 if ((firstWaiter = first.nextWaiter) == null) lastWaiter = null; first.nextWaiter = null; // 5. 使用死循環(huán)，一定要轉移一個節(jié)點到同步隊列 } while (!transferForSignal(first) && (first = firstWaiter) != null);}到底是怎么轉移到同步隊列末尾的？
// 實際轉移方法final boolean transferForSignal(Node node) { // 1. 把節(jié)點狀態(tài)從CONDITION改成0，表示從條件隊列轉移到同步隊列 if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) return false; // 2. 使用死循環(huán)的方式，追加到同步隊列末尾（前面已經(jīng)講過） Node p = enq(node); int ws = p.waitStatus; // 3. 把前驅(qū)節(jié)點狀態(tài)設置SIGNAL（通知他，別忘了喚醒老弟） if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) LockSupport.unpark(node.thread); return true;}上篇文章講了AQS的架構設計和排它鎖的加鎖、釋放鎖流程，下篇文章接著講共享鎖的加鎖、釋放鎖流程。這篇文章開始講AQS的共享鎖加鎖和釋放鎖流程。
先看共享鎖的加鎖流程：
// 加鎖方法，傳參是1，表示加鎖一次public final void acquireShared(int arg) { // 1. 首先嘗試獲取鎖，返回值小于0，表示獲取鎖失敗 if (tryAcquireShared(arg) < 0) { // 2. 獲取鎖失敗后，執(zhí)行的邏輯 doAcquireShared(arg); }}// 獲取鎖失敗，執(zhí)行的邏輯private void doAcquireShared(int arg) { // 1. 把當前線程包裝成Node節(jié)點追加到同步隊列末尾（前面已經(jīng)講過） final Node node = addWaiter(Node.SHARED); boolean failed = true; try { boolean interrupted = false; for (; ; ) { // 2. 找到前驅(qū)節(jié)點 final Node p = node.predecessor(); // 3. 如果前驅(qū)節(jié)點是頭結點，就再次嘗試獲取鎖 if (p == head) { int r = tryAcquireShared(arg); if (r >= 0) { // 3. 獲取鎖成功后，把自己設置為頭節(jié)點并向后傳播 setHeadAndPropagate(node, r); p.next = null; // 4. 檢查中斷狀態(tài) if (interrupted) { selfInterrupt(); } failed = false; return; } } // 4. 如果獲取鎖失敗，把前驅(qū)節(jié)點狀態(tài)設置成SIGNAL，用來喚醒自己（前面講過） if (shouldParkAfterFailedAcquire(p, node) && // 掛起并中斷當前線程 parkAndCheckInterrupt()) { interrupted = true; } } } finally { // 5. 如果獲取鎖失敗，就取消當前節(jié)點 if (failed) { cancelAcquire(node); } }}看一下上面的第三步設置頭節(jié)點的邏輯，setHeadAndPropagate() 方法的作用就是：
這里就是共享鎖與排它鎖的區(qū)別，共享鎖的同步隊列中某個節(jié)點獲取到鎖時，會向后傳播，喚醒其他節(jié)點，也就是通知隊列中其他節(jié)點一起獲取鎖，。
// 設置頭節(jié)點，并向后傳播private void setHeadAndPropagate(Node node, int propagate) { Node h = head; setHead(node); // propagate > 0 表示獲取到了共享鎖 // h == null || h.waitStatus < 0 表示當前頭節(jié)點已經(jīng)不再是有效節(jié)點，可能是被取消或者已經(jīng)釋放了鎖，需要進行傳播。 // 再次判斷頭節(jié)點，防止在設置頭節(jié)點的過程中發(fā)生競爭 if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) { Node s = node.next; // 判斷如果后繼節(jié)點為空或者是共享節(jié)點，就開始傳播共享鎖 if (s == null || s.isShared()) { doReleaseShared(); } }}再看一下上面第五步，獲取鎖失敗后，取消當前節(jié)點的邏輯：
// 取消獲取鎖private void cancelAcquire(Node node) { // 判空 if (node == null) { return; } // 1. 設置線程為null，不再持有鎖 node.thread = null; // 2. 如果前驅(qū)節(jié)點是取消狀態(tài)，繼續(xù)向前遍歷，找到不是取消狀態(tài)的前驅(qū)節(jié)點 Node pred = node.prev; while (pred.waitStatus > 0) { node.prev = pred = pred.prev; } Node predNext = pred.next; // 3. 把當前節(jié)點設置為取消狀態(tài)，不再獲取鎖 node.waitStatus = Node.CANCELLED; // 4. 判斷如果當前節(jié)點是尾節(jié)點，就刪除當前節(jié)點 if (node == tail && compareAndSetTail(node, pred)) { compareAndSetNext(pred, predNext, null); } else { // 5. 判斷后繼節(jié)點是否需要被喚醒 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) { // 6. 刪除當前節(jié)點 compareAndSetNext(pred, predNext, next); } } else { // 7. 喚醒后繼節(jié)點 unparkSuccessor(node); } node.next = node; }}看一下釋放鎖的邏輯：
// 釋放鎖，傳參是1，表示釋放鎖一次public final boolean releaseShared(int arg) { // 先嘗試釋放鎖 if (tryReleaseShared(arg)) { // 釋放鎖成功后，要執(zhí)行的邏輯 doReleaseShared(); return true; } return false;}再看一下釋放鎖成功后，要執(zhí)行的 doReleaseShared() 方法的邏輯，作用是：
// 釋放鎖成功后，要執(zhí)行的邏輯private void doReleaseShared() { for (; ; ) { Node h = head; // 判斷是否等于尾節(jié)點，如果是尾節(jié)點，就不用傳播了 if (h != null && h != tail) { // 判斷節(jié)點狀態(tài)，如果是SIGNAL，則需要被喚醒 int ws = h.waitStatus; if (ws == Node.SIGNAL) { // 重置head節(jié)點狀態(tài)，表示開始喚醒下個節(jié)點。如果重置失敗，說明發(fā)生了競爭，需要再次嘗試。 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0)) { continue; } // 喚醒下一個節(jié)點 unparkSuccessor(h); // 如果節(jié)點狀態(tài)是0，則需要設置成PROPAGATE，繼續(xù)傳播 } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE)) { continue; } } // 如果頭節(jié)點沒變，表示循環(huán)中沒有進行頭節(jié)點的修改，說明已經(jīng)處理完了需要喚醒的節(jié)點，可以退出循環(huán)。 if (h == head) { break; } }}本文鏈接：http://www.www897cc.com/showinfo-26-75294-0.html沒看過AQS源碼，別說精通Java并發(fā)編程
聲明：本網(wǎng)頁內(nèi)容旨在傳播知識，若有侵權等問題請及時與本網(wǎng)聯(lián)系，我們將在第一時間刪除處理。郵件：2376512515@qq.com
Copyright ? 2016-2023 天津谷騏科技有限公司 版權所有 sitemap.xml
違法及侵權請聯(lián)系：2376512515@qq.com 津ICP備18001702號
津公網(wǎng)安備 12010102000574號