09-J.U.C之併發工具類：CountDownLatch

1. 簡介

      CountDownLatch與CyclicBarrier有點兒相似。

      CyclicBarrier所描述的是“允許一組線程互相等待，直到到達某個公共屏障點，纔會進行後續任務"，而CountDownLatch所描述的是”在完成一組正在其他線程中執行的操作之前，它允許一個或多個線程一直等待“。

      在API中是這樣描述的：

      用給定的計數初始化 CountDownLatch。由於調用了 countDown() 方法，所以在當前計數到達零之前，await 方法會一直受阻塞。之後，會釋放所有等待的線程，await 的所有後續調用都將立即返回。

      這種現象只出現一次——計數無法被重置。如果需要重置計數，請考慮使用 CyclicBarrier。

      CountDownLatch是通過一個計數器來實現的，當我們在new 一個CountDownLatch對象的時候需要帶入該計數器值，該值就表示了線程的數量。每當一個線程完成自己的任務後，計數器的值就會減1。當計數器的值變爲0時，就表示所有的線程均已經完成了任務，然後就可以恢復等待的線程繼續執行了。

2. 實現分析

      通過上圖我們可以看到，CountDownLatch內部依賴Sync實現，而Sync繼承AQS。

      CountDownLatch僅提供了一個構造方法：CountDownLatch(int count) ： 構造一個用給定計數初始化的CountDownLatch。

public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    this.sync = new Sync(count);
}

      sync爲CountDownLatch的一個內部類，其定義如下：

private static final class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 4982264981922014374L;

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

    //獲取同步狀態
    int getCount() {
        return getState();
    }

    //獲取同步狀態
    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;
    }

    //釋放同步狀態
    protected boolean tryReleaseShared(int releases) {
        for (;;) {
            int c = getState();
            if (c == 0)
                return false;
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }
}

      通過這個內部類Sync我們可以清楚地看到CountDownLatch是採用共享鎖來實現的。

2.1 await()

      CountDownLatch提供await()方法來使當前線程在鎖存器倒計數至零之前一直等待，除非線程被中斷，定義如下：

public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

      await其內部使用AQS的acquireSharedInterruptibly(int arg)：

public final void acquireSharedInterruptibly(int arg)
    throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 查看當前計數器的值是否爲0，爲0則直接返回，否則進入AQS的隊列等待
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

      在內部類Sync中重寫了tryAcquireShared(int arg)方法：

	protected int tryAcquireShared(int acquires) {
	    return (getState() == 0) ? 1 : -1;
	}

      getState()獲取同步狀態，其值等於計數器的值，從這裏我們可以看到如果計數器值不等於0，則會調用doAcquireSharedInterruptibly(int arg)，該方法爲一個自旋方法會嘗試一直去獲取同步狀態：

private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                /**
                 * 對於CountDownLatch而言，如果計數器值不等於0，那麼r 會一直小於0
                 */
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            //等待
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

2.2 countDown()

      CountDownLatch提供countDown()方法遞減鎖存器的計數，如果計數到達零，則釋放所有等待的線程。

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

      內部調用AQS的releaseShared(int arg)方法來釋放共享鎖同步狀態：

	public final boolean releaseShared(int arg) {
	    if (tryReleaseShared(arg)) {
	        doReleaseShared();
	        return true;
	    }
	    return false;
	}

      tryReleaseShared(int arg)方法被CountDownLatch的內部類Sync重寫：

protected boolean tryReleaseShared(int releases) {
    for (;;) {
        //獲取鎖狀態
        int c = getState();
        //c == 0 直接返回，釋放鎖成功
        if (c == 0)
            return false;
        //計算新“鎖計數器”
        int nextc = c-1;
        //更新鎖狀態（計數器）
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

      如果 tryReleaseShared 方法返回 true，說明是最後一個線程調用的countdown方法，那麼該線程除了讓計數器值減1之外，還需要喚醒因調用 CountdownLatch 的 await 方法而被阻塞的線程。

3. 總結

      CountDownLatch內部通過共享鎖實現。在創建CountDownLatch實例時，需要傳遞一個int型的參數：count，該參數爲計數器的初始值，也可以理解爲該共享鎖可以獲取的總次數。

      當某個線程調用await()方法，程序首先判斷count的值是否爲0，如果不爲0的話則會一直等待直到爲0爲止。當其他線程調用countDown()方法時，則執行釋放共享鎖狀態，使count值-1。

      當在創建CountDownLatch時初始化的count參數，必須要有count線程調用countDown方法纔會使計數器count等於0，鎖纔會釋放，前面等待的線程纔會繼續運行。注意CountDownLatch不能回滾重置。

4. 應用示例

public class CountDownLatchTest {
    private static CountDownLatch countDownLatch = new CountDownLatch(5);

    /**
     * Boss線程，等待員工到達開會
     */
    static class BossThread extends Thread{
        @Override
        public void run() {
            System.out.println("Boss在會議室等待，總共有" + countDownLatch.getCount() + "個人開會...");
            try {
                //Boss等待
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("所有人都已經到齊了，開會吧...");
        }
    }

    //員工到達會議室
    static class EmpleoyeeThread  extends Thread{
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + "，到達會議室....");
            //員工到達會議室 count - 1
            countDownLatch.countDown();
        }
    }

    public static void main(String[] args){
        //Boss線程啓動
        new BossThread().start();

        for(int i = 0,j = countDownLatch.getCount() ; i < j ; i++){
            new EmpleoyeeThread().start();
        }
    }
}