本文適合AQS有一定基礎的伙伴進行閱讀泛释，對其中比較重點的內容做一個簡單的總結，本文不會對AQS基礎框架和源碼進行很詳細的分析温算，網上有很多這種資源怜校，大家可以先深入了解一下，直接上干貨注竿。
一茄茁、互斥鎖與共享鎖
AQS是鎖實現的基礎框架，AQS區(qū)別了互斥鎖與共享鎖的實現方式巩割，互斥鎖就是只有一個線程同一時刻可以獲得鎖裙顽，共享鎖是同一時刻可以有多個線程可以獲得鎖（這里不要與讀與寫進行關聯，我之前有一段時間也有這種誤區(qū)）宣谈，但是這兩種鎖是否能夠獲得到鎖愈犹，是實現鎖功能的類實現的如（ReentrantLock、ReentrantReadWriteLock）闻丑，一般都需要實現如下幾個方法漩怎。
1.互斥鎖
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
首先調用實現鎖的tryAcquire來判斷是否能獲得鎖，若不能獲得鎖則初始化一個EXCLUSIVE類型的Node節(jié)點梆掸，并以CAS配合自旋的方式放入同步隊列尾部扬卷，然后再看該節(jié)點是否在同步隊列的首節(jié)點后牙言，如果是再次調用tryAcquire酸钦，如果不能獲得到鎖
該線程就會阻塞（ LockSupport.park實現）。
二咱枉、共享鎖
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
private void doAcquireShared(int arg) {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
調用實現鎖的tryAcquireShared方法卑硫，如果<0代表沒有獲得鎖，直接調用doAcquireShared方法蚕断，該方法的大部分與互斥鎖很相似欢伏，但是其中的不同是setHeadAndPropagate方法，該方法是在獲得鎖后實現了一個"傳播行為"亿乳，依次喚醒同步隊列中的SHARE節(jié)點硝拧。
二径筏、公平鎖與非公平鎖
公平鎖與非公平鎖是針對ASQ框架所實現的鎖（不是AQS自身實現，這點很重要）障陶，我個人的理解是公平鎖是按照申請鎖的順序獲取鎖滋恬，而非公平鎖就沒有這樣嚴格的要求，那么我們知道要實現鎖抱究，都需要實現AQS的核心方法（源碼可以查看ReentrantLock中的NonfairSync和FairSync）恢氯，那我們看一下公平鎖與非公平鎖的具體實現。
1.非公平鎖
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()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
根據state==0的條件（狀態(tài)）來嘗試上鎖鼓寺，通過CAS的方式成功更改了state則獲得到鎖勋拟，且支持重入，如果沒有獲得到鎖返回false妈候，后面的操作和ASQ的互斥鎖的流程一致敢靡，這里不做過多的介紹了。
2.公平鎖
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
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;
}
整段方法大家可以看到處理過程中多了一個hasQueuedPredecessors方法苦银，其他大部分都很相似醋安，這也是公平鎖與非公平鎖的控制的關鍵，主要實現的就是判斷當前是否已經存在等待的線程墓毒，如果存在則不能獲得鎖吓揪，老老實實的在AQS的同步隊列中進行排隊。
三所计、讀寫鎖
在ReentrantReadWriteLock中有兩個鎖柠辞，一個是ReadLock、一個是WriteLock主胧，一般適用于多讀少寫的一些場景叭首，之前我提過所有的鎖都是基于AQS進行的實現，所以讀寫鎖也一樣踪栋，只是針對于這種場景（可以同一時間并發(fā)讀焙格，但是只要有寫就阻塞）進行了處理。
1.讀鎖
protected final int tryAcquireShared(int unused) {
Thread current = Thread.currentThread();
int c = getState();
if (exclusiveCount(c) != 0 &&
getExclusiveOwnerThread() != current)
return -1;
int r = sharedCount(c);
if (!readerShouldBlock() &&
r < MAX_COUNT &&
compareAndSetState(c, c + SHARED_UNIT)) {
if (r == 0) {
firstReader = current;
firstReaderHoldCount = 1;
} else if (firstReader == current) {
firstReaderHoldCount++;
} else {
HoldCounter rh = cachedHoldCounter;
if (rh == null || rh.tid != getThreadId(current))
cachedHoldCounter = rh = readHolds.get();
else if (rh.count == 0)
readHolds.set(rh);
rh.count++;
}
return 1;
}
return fullTryAcquireShared(current);
}
在讀寫鎖中state32位夷都，高16位為讀鎖獲取的次數眷唉，低16位是互斥鎖獲取的次數，如果獲取讀鎖時已經有其他線程獲得了寫鎖那就直接返回獲得鎖失敗囤官。如果沒有人獲得寫鎖冬阳，那就直接修改state的值，代表本線程獲得到了讀鎖党饮。如果r==0說明沒有人獲得讀鎖肝陪，則給firstReader設置為當前線程，重入次數為1刑顺，如果firstReader已經是自身線程氯窍，則重入次數加1（支持重入）饲常，如果都不是，則從緩存中獲得重入次數并自增狼讨，如果本方法沒有獲得鎖那還是根據AQS共享鎖的原理在同步隊列等待不皆。
讀鎖的釋放這里不做過多的描述，大概的思路是如果當前線程是firstReader且重入次數為1則設置firstReader為空熊楼，如果不是則獲取緩存中的重入數量減1霹娄，如果減完后為0則返回true，進行同步隊列中線程的喚醒鲫骗，其他時候返回false犬耻。
2.寫鎖
protected final boolean tryAcquire(int acquires) {
Thread current = Thread.currentThread();
int c = getState();
int w = exclusiveCount(c);
if (c != 0) {
// (Note: if c != 0 and w == 0 then shared count != 0)
if (w == 0 || current != getExclusiveOwnerThread())
return false;
if (w + exclusiveCount(acquires) > MAX_COUNT)
throw new Error("Maximum lock count exceeded");
// Reentrant acquire
setState(c + acquires);
return true;
}
if (writerShouldBlock() ||
!compareAndSetState(c, c + acquires))
return false;
setExclusiveOwnerThread(current);
return true;
}
如果state!=0且w==0，說明有讀鎖的獲取次不為0执泰，getExclusiveOwnerThread說明其他線程獲得了寫鎖枕磁，以上兩種情況都返回獲取鎖失敗，如果該線程通過重入獲取鎖成功則重新設置state的值术吝，返回true计济。如果在上一步state為0則直接嘗試獲得寫鎖，獲得到返回true排苍，獲取不到鎖返回false沦寂，后續(xù)流程就與AQS是互斥鎖一致了。
釋放鎖的過程也類似淘衙，修改state的值（減releases）传藏，如果重入為0則設置OwnerThread為null，返回true彤守，喚醒同步隊列中的線程毯侦。
四、CountDownLatch
在CountDownLatch進行初始化的時候會設置state的個數具垫，每當執(zhí)行countDown方式的時候就會調用tryReleaseShared方法將state減1侈离，如果最后state不為0則一直都返回false，一旦state為0筝蚕，則會喚醒等待隊列中的線程卦碾。
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
上面簡述了喚醒等待線程的過程，那這些進程是如何進入到隊列中的饰及，其實是調用了CountDownLatch的await方法蔗坯，await方法內部調用了acquireSharedInterruptibly方法，如果state不為0也就是還有線程沒有運行燎含，則所有的await線程要進入到等待隊列中。
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
五腿短、Semaphore
該鎖也成為信號量屏箍，同一時刻最多只有N個線程可以同時工作绘梦，可以實現簡單的限流，底層的實現也是基于AQS赴魁，在該鎖中也可以實現公平鎖與非公平鎖兩種方式卸奉。
1.獲得許可（以非公平鎖為例）
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
當線程想獲得一個鎖的時候，該鎖實現了可中斷和非終端兩種方式颖御，nonfairTryAcquireShared方法是一個自旋榄棵，根據state獲得現在還剩下的許可數，然后減想獲得的許可數潘拱，如果剩余的許可小于0則返回一個負數疹鳄，該線程進入到AQS是同步隊列中。如果剩余的許可數大于0芦岂，則會更新state的許可數瘪弓，然后返回一個正數，該線程獲得鎖禽最。
2.釋放許可
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
釋放一個許可也很簡單腺怯，獲得當前的許可數state，將釋放的許可數疊在state上（可以提供這種方式動態(tài)的增加許可的數量）川无，然后對state進行更新呛占，如果更新成功則返回true，依次喚醒同步隊列中的線程獲取鎖懦趋。
小結:AQS的核心就是互斥鎖和共享鎖的實現流程栓票，至于其他出現的鎖，都是在AQS的基礎上實現的愕够，比如ReentrantLock走贪、ReentrantReadWriteLock、CountDownLatch惑芭、Semaphore等坠狡，我看源碼的時候最后就是充分的理解了這句話才對整個AQS理解更加的深刻。
