public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}
// 帶有超時時間的，最終都會轉化成毫秒
public boolean await(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

private static final class Sync extends AbstractQueuedSynchronizer {}

// 如果當前同步器的狀態(tài)是 0 的話，表示可獲得鎖
protected int tryAcquireShared(int acquires) {
    return (getState() == 0) ? 1 : -1;
}

// 初始化,count 代表 state 的初始化值
public CountDownLatch(int count) {
    if (count < 0) throw new IllegalArgumentException("count < 0");
    // new Sync 底層代碼是 state = count;
    this.sync = new Sync(count);
}

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

// 對 state 進行遞減，直到 state 變成 0；
// state 遞減為 0 時，返回 true，其余返回 false
protected boolean tryReleaseShared(int releases) {
    // 自旋保證 CAS 一定可以成功
    for (;;) {
        int c = getState();
        // state 已經(jīng)是 0 了，直接返回 false
        if (c == 0)
            return false;
        // 對 state 進行遞減
        int nextc = c-1;
        if (compareAndSetState(c, nextc))
            return nextc == 0;
    }
}

public class CountDownLatchDemo {
  // 線程任務
  class Worker implements Runnable {
    // 定義計數(shù)鎖用來實現(xiàn)功能 1
    private final CountDownLatch startSignal;
    // 定義計數(shù)鎖用來實現(xiàn)功能 2
    private final CountDownLatch doneSignal;
    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
      this.startSignal = startSignal;
      this.doneSignal = doneSignal;
    }
		// 子線程做的事情
    public void run() {
      try {
        System.out.println(Thread.currentThread().getName()+" begin");
        // await 時有兩點需要注意：await 時 state 不會發(fā)生變化，2：startSignal 的state初始化是 1，所以所有子線程都是獲取不到鎖的，都需要到同步隊列中去等待，達到先啟動的子線程等待后面啟動的子線程的結果
        startSignal.await();
        doWork();
        // countDown 每次會使 state 減一，doneSignal 初始化為 9，countDown 前 8 次執(zhí)行都會返回 false (releaseShared 方法)，執(zhí)行第 9 次時，state 遞減為 0，會 countDown 成功，表示所有子線程都執(zhí)行完了，會釋放 await 在 doneSignal 上的主線程
        doneSignal.countDown();
        System.out.println(Thread.currentThread().getName()+" end");
      } catch (InterruptedException ex) {
      } // return;
    }
    void doWork() throws InterruptedException {
      System.out.println(Thread.currentThread().getName()+"sleep 5s …………");
      Thread.sleep(5000l);
    }
  }
  @Test
  public void test() throws InterruptedException {
    // state 初始化為 1 很關鍵，子線程是不斷的 await，await 時 state 是不會變化的，并且發(fā)現(xiàn) state 都是 1，所有線程都獲取不到鎖
    // 造成所有線程都到同步隊列中去等待，當主線程執(zhí)行 countDown 時，就會一起把等待的線程給釋放掉
    CountDownLatch startSignal = new CountDownLatch(1);
    // state 初始化成 9，表示有 9 個子線程執(zhí)行完成之后，會喚醒主線程
    CountDownLatch doneSignal = new CountDownLatch(9);
    for (int i = 0; i < 9; ++i) // create and start threads
    {
      new Thread(new Worker(startSignal, doneSignal)).start();
    }
    System.out.println("main thread begin");
    // 這行代碼喚醒 9 個子線程，開始執(zhí)行(因為 startSignal 鎖的狀態(tài)是 1，所以調用一次 countDown 方法就可以釋放9個等待的子線程)
    startSignal.countDown();
    // 這行代碼使主線程陷入沉睡，等待 9 個子線程執(zhí)行完成之后才會繼續(xù)執(zhí)行(就是等待子線程執(zhí)行 doneSignal.countDown())
    doneSignal.await();           
    System.out.println("main thread end");
  }
}

private volatile int value;
// 初始化
public AtomicInteger(int initialValue) {
    value = initialValue;
}
// 得到當前值
public final int get() {
    return value;
}
// 自增 1，并返回自增之前的值    
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
// 自減 1，并返回自增之前的值    
public final int getAndDecrement() {
    return unsafe.getAndAddInt(this, valueOffset, -1);
}

// 對 x 執(zhí)行 accumulatorFunction 操作
// accumulatorFunction 是個函數(shù)，可以自定義想做的事情
// 返回老值
public final V getAndAccumulate(V x,
                                BinaryOperator<V> accumulatorFunction) {
    // prev 是老值，next 是新值
    V prev, next;
    // 自旋 + CAS 保證一定可以替換老值
    do {
        prev = get();
        // 執(zhí)行自定義操作
        next = accumulatorFunction.apply(prev, x);
    } while (!compareAndSet(prev, next));
    return prev;
}