併發流程工具CountDownLatch解析

CountDownLatch是一個線程併發流程工具，它允許一個或者多個線程阻塞直到一些線程執行完畢，纔會繼續執行，CountDownLatch會存在一個計數器，當 await方法調用，那麼後面的線程都會被阻塞，直到由於countDown()方法的調用而導致當前計數達到零，後續被阻塞的線程纔會繼續執行，這個計數器是一次性的，不能重置，如果需要重置計數，請考慮使用CyclicBarrier

CountDownLatch內部是通過AQS實現併發流程控制，在的內部有一個AQS類

/**
     * 用於控制	CountDownLatch.
     * 用AQS的狀態代替計數器.
     */
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
//傳入計數值，將其設置爲AQS狀態， setState(count)是父類的一個方法，狀態變化整體是可見的
        Sync(int count) {
            setState(count);
        }
//獲得當前的狀態。同樣調的是父類的方法
        int getCount() {
            return getState();
        }

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

        protected boolean tryReleaseShared(int releases) {
            // 自旋的方式，判斷狀態如果爲0直接執行被阻塞的線程
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                //利用CAS更新狀態
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

//父類方法用於設置狀態
  /**
     * 設置AQS狀態
     * 
     */
    protected final void setState(int newState) {
    // private volatile int state;，保證可見行
        state = newState;
    }

//用於阻塞後續所有的線程
 public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

//阻塞後續線程，直到計數器爲0或者超時
 public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

 /**
     *
     * 計數器減一，當計數器爲0的時候後續阻塞線程會繼續執行
     *
     * 如果計數器已經爲0，調用此方法不會做任何事
     */
    public void countDown() {
    //利用AQS的狀態量去控制
        sync.releaseShared(1);
    }

 /**
     * 返回計數器
     */
    public long getCount() {
        return sync.getCount();
    }

構造方法

 /**
     * 初始化一個對象，並設置計數器數量和AQS的狀態量
     * 如果傳入一個負數回報參數異常
     */
    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

案例

/**
 * 描述：     模擬一個連隊，所有人都到齊了才統一出發
 */
public class CountDownLatchDemo1 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(12);
        ExecutorService service = Executors.newFixedThreadPool(12);
        for (int i = 0; i < 12; i++) {
            final int no = i + 1;
            Runnable runnable = new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("No." + no + "達到連隊。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        latch.countDown();
                    }
                }
            };
            service.submit(runnable);
        }
        System.out.println("所有人都到齊了.....");
        latch.await();
        System.out.println("所有人都到齊了，出發！！！！！。");
    }
}

/**
 * 描述：     模擬100米跑步，5名選手都準備好了，只等裁判員一聲令下，所有人同時開始跑步。當所有人都到終點後，比賽結束。
 */
public class CountDownLatchDemo1And2 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch begin = new CountDownLatch(1);

        CountDownLatch end = new CountDownLatch(5);
        ExecutorService service = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            final int no = i + 1;
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("No." + no + "準備完畢，等待發令槍");
                    try {
                        begin.await();
                        System.out.println("No." + no + "開始跑步了");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("No." + no + "跑到終點了");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        end.countDown();
                    }
                }
            };
            service.submit(runnable);
        }
        //裁判員檢查發令槍...
        Thread.sleep(5000);
        System.out.println("發令槍響，比賽開始！");
        begin.countDown();

        end.await();
        System.out.println("所有人到達終點，比賽結束");
    }
}