@Slf4j(topic = "a.CountDownLatchTest")
public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        // 創(chuàng)建一個倒時器，默認(rèn)10個數(shù)量
        CountDownLatch latch = new CountDownLatch(10);
        ExecutorService service = Executors.newFixedThreadPool(10);
        // 設(shè)置進度數(shù)據(jù)
        String[] personProcess = new String[10];
        Random random = new Random();

        for (int i = 0; i < 10; i++) {
            int finalJ = i;
            service.submit(() -> {
                // 模擬10個人的進度條
                for (int j = 0; j <= 100; j++) {
                    // 模擬網(wǎng)速快慢，隨機生成
                    try {
                        Thread.sleep(random.nextInt(100));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 設(shè)置進度數(shù)據(jù)
                    personProcess[finalJ] = j + "%";
                   log.info("{}", Arrays.toString(personProcess));
                }

                // 運行結(jié)束，倒時器 - 1
                latch.countDown();
            });
        }
        // 打開"閥門"
        latch.await();
       log.info("王者峽谷到了");
        service.shutdown();
    }
}

// CountDownLatch#await
public void await() throws InterruptedException {
    // 調(diào)用AbstractQueuedSynchronizer的acquireSharedInterruptibly方法
    sync.acquireSharedInterruptibly(1);
}
// AbstractQueuedSynchronizer#acquireSharedInterruptibly
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
    // 判斷線程是否被打斷，拋出打斷異常
    if (Thread.interrupted())
        throw new InterruptedException();
    // 嘗試獲取共享鎖
    // 條件成立說明 state > 0，此時線程入隊阻塞等待，等待其他線程獲取共享資源
    // 條件不成立說明 state = 0，此時不需要阻塞線程，直接結(jié)束函數(shù)調(diào)用
    if (tryAcquireShared(arg) < 0)
        // 阻塞當(dāng)前線程的邏輯
        doAcquireSharedInterruptibly(arg);
}
// CountDownLatch.Sync#tryAcquireShared
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

// AbstractQueuedSynchronizer#doAcquireSharedInterruptibly
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
    // 將調(diào)用latch.await()方法的線程 包裝成 SHARED 類型的 node 加入到 AQS 的阻塞隊列中
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            // 獲取當(dāng)前節(jié)點的前驅(qū)節(jié)點
            final Node p = node.predecessor();
            // 前驅(qū)節(jié)點時頭節(jié)點就可以嘗試獲取鎖
            if (p == head) {
                // 再次嘗試獲取鎖，獲取成功返回 1
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // 獲取鎖成功，設(shè)置當(dāng)前節(jié)點為 head 節(jié)點，并且向后傳播
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            // 阻塞在這里
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        // 阻塞線程被中斷后拋出異常，進入取消節(jié)點的邏輯
        if (failed)
            cancelAcquire(node);
    }
}

private final boolean parkAndCheckInterrupt() {
    	// 阻塞線程
        LockSupport.park(this);
        return Thread.interrupted();
    }

public void countDown() {
    sync.releaseShared(1);
}

public final boolean releaseShared(int arg) {
    // 嘗試釋放共享鎖
    if (tryReleaseShared(arg)) {
        // 釋放鎖成功開始喚醒阻塞節(jié)點
        doReleaseShared();
        return true;
    }
    return false;
}

protected boolean tryReleaseShared(int releases) {
    for (;;) {
        int c = getState();
        // 條件成立說明前面【已經(jīng)有線程觸發(fā)喚醒操作】了，這里返回 false
        if (c == 0)
            return false;
        // 計數(shù)器減一
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            // 計數(shù)器為 0 時返回 true
            return nextc == 0;
    }
}

private void doReleaseShared() {
    for (;;) {
        Node h = head;
        // 判斷隊列是否是空隊列
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            // 頭節(jié)點的狀態(tài)為 signal，說明后繼節(jié)點沒有被喚醒過
            if (ws == Node.SIGNAL) {
                // cas 設(shè)置頭節(jié)點的狀態(tài)為 0，設(shè)置失敗繼續(xù)自旋
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;
                // 喚醒后繼節(jié)點
                unparkSuccessor(h);
            }
            // 如果有其他線程已經(jīng)設(shè)置了頭節(jié)點的狀態(tài)，重新設(shè)置為 PROPAGATE 傳播屬性
            else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;
        }
        // 條件不成立說明被喚醒的節(jié)點非常積極，直接將自己設(shè)置為了新的head，
        // 此時喚醒它的節(jié)點（前驅(qū)）執(zhí)行 h == head 不成立，所以不會跳出循環(huán)，會繼續(xù)喚醒新的 head 節(jié)點的后繼節(jié)點
        if (h == head)
            break;
    }
}