CountDownLatch類運用了java開發模式中的策略模式。對線程作用的是CountDownLatch類中的內部類Sync。
Sync類繼承了AbstractQueuedSynchronizer類,AbstractQueuedSynchronizer類是jdk多線程同步功能的重要類。CountDownLatch類有兩個很重要的方法:await和countDown。這兩個方法內分別調用的是AbstractQueuedSynchronizer的方法acquireSharedInterruptibly(int arg)和releaseShared(int arg)
CountDownLatch類的邏輯是:使用CountDownLatch類,每個線程都公用一個初始化count的CountDownLatch對象常量,並在線程執行完成的時候調用countDown(),並在主線程使用await()進入阻塞狀態,直到所有的任務完成,當count 減到0的時候開始執行主線程代碼。
應用場景是:1.一個線程等待多個其它線程執行完成。多個線程等待其他多個線程執行完成。
這種多線程同步工具適用於在軟件系統中,在開始某些任務前必須初始化一些系統數據,任務線程就必須等待系統數據初始化數據的完成,大型軟件業務系統或計算系統就需要者同步工具。
CountDownLatch中重要 的兩個方法:await()和countDown():
await(): 這個方法調用的是 sync.acquireSharedInterruptibly(1);
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//檢驗當前線程是否設置了阻斷標識位爲true
if (Thread.interrupted())
throw new InterruptedException();
//嘗試獲取 分享模式下的鎖
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
tryAcquireShared(int acquires)方法試圖獲取分享模式下的鎖,這個方法由CountDownLatch類中的內部類Sync類實現,方法的源碼如下:
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
tryAcquireShared方法的意義是:同步鎖的狀態字段state爲0,就返回-1,不爲0就返回1.也就是說state的值爲0,共享鎖就能被線程獲取,主線程能繼續執行,如果是大於0,則表示主線程不能執行,併發生阻塞,進入鎖的獲取阻塞線程隊列中去,可CountDownLatch類創建的時候會傳進去一個值並賦給state屬性。共享鎖獲取成功後會執行doAcquireSharedInterruptibly(int arg)函數,該方法是將獲取鎖的等待線程都放入到阻塞隊列中去,源代碼如下:
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//同步等待隊列中的頭節點設置爲空值的Node,表示同步鎖處於共享模式
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) { //這裏獲取鎖成功後,喚醒下一個AQS隊列中的下一個線程,但當前的後繼節點爲當前線程,所以下面會將後繼節點設置爲head。
setHeadAndPropagate(node, r);//激活下一個節點,本線程繼續運行。
p.next = null; // help GC
failed = false;
return;
}
}
//如果獲取共享鎖失敗,就掛起線程。
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
//在上面if中,線程被掛起阻塞了,當被喚醒後會繼續執行循環
}
} finally {
if (failed)
cancelAcquire(node);
}
}
如果線程獲取了共享鎖,就調用setHeadAndPropagate()方法將下一個節點也激活(獲取共享鎖),這個激活的方法源碼如下:
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);
/*
* Try to signal next queued node if:
* Propagation was indicated by caller,
* or was recorded (as h.waitStatus) by a previous operation
* (note: this uses sign-check of waitStatus because
* PROPAGATE status may transition to SIGNAL.)
* and
* The next node is waiting in shared mode,
* or we don't know, because it appears null
*
* The conservatism in both of these checks may cause
* unnecessary wake-ups, but only when there are multiple
* racing acquires/releases, so most need signals now or soon
* anyway.
*/
if (propagate > 0 || h == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
首先使用setHead方法將頭結點的後繼節點設置爲頭節點,下面if語句中propagate>0表示AQS隊列上的所有線程都能獲取共享鎖,然後如果下一個節點爲共享模式線程節點(isShared())就將下一個節點喚醒doReleaseShared();
private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {//如果頭節點狀態爲signal(-1),即立刻喚醒頭結點後驅節點指向的線程。
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//如果頭結點的狀設置的原子操作失敗,則重複設置。
continue; // loop to recheck cases
unparkSuccessor(h);//喚醒head下個節點的線程。
}
else if (ws == 0 && //如果頭節點狀態爲0,即節點初始化狀態,則直接設置頭結點狀態變爲PROPAGATE(-3)
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;//循環在此結束,當head頭節點沒有發生變化
}
}
共享模式下,所有AQS隊列下的線程都會被喚醒。
countDown()方法調用的是AQS類的releaseShared(1)方法,方法源碼如下:
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
tryReleaseShared(1)返回成功後就執行doReleaseShared方法。tryReleaseShared方法是將state值減掉個1,並賦給它值。如果state值本來就是0,則返回false,只有當
當state減去1後值爲0的時候,函數返回true。然後就將AQS中所有的阻塞線程都依次喚醒。
總結:到這裏我們可以看到,在這個多線程同步模式下,如果你有number個線程需要提前執行完成,你就需要創建stae值爲number的CountDownLatch類對象c,然後將對象c
的值傳給我們提前執行的線程和需要等待執行的線程。在這兩中線程中分別調用c對象的countDown方法和await方法。在此主要實現這個功能的類是AQS類。不過這個同步鎖是一個
共享鎖,而不是以前接觸的獨佔鎖,兩種模式的區別是:共享鎖等待隊列中,只要一個節點獲取了鎖,那麼所有的節點都能獲取鎖,而獨佔模式就不一樣了,一個阻塞節點是要唯一擁有
鎖的。
以上就是對多線程同步工具類CountDownLatch的源碼原理分析。