public static void main(String[] args) {
        System.out.println("main 線程開始執(zhí)行！");
        CountDownLatch latch = new CountDownLatch(5);//初始化同步數(shù)
        for (int i = 0; i < 5; i++) {
            int threadId = i+1;
            new Thread(()->{
                System.out.println("線程"+threadId+"執(zhí)行！");
                latch.countDown();
            }).start();//java8 lamda表達式
        }
        System.out.println("即將被阻塞！");
        try {
            latch.await();//阻塞主線程,等待子線程將state減至0被喚醒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main 線程執(zhí)行完畢！");
    }

 /**
  * CountDownLatch唯一的構造函數(shù),實例化時只能使用指定同步數(shù)的構造方法
  */
  public CountDownLatch(int count) {
      if (count < 0) throw new IllegalArgumentException("count < 0");
      this.sync = new Sync(count);//利用內部類(繼承AQS)對state進行設置初始化大小
  }

public void await() throws InterruptedException {
    //核心成員變量sync調用AQS中的方法acquireSharedInterruptibly
    sync.acquireSharedInterruptibly(1);
}

  public final void acquireSharedInterruptibly(int arg)
              throws InterruptedException {
      if (Thread.interrupted())//判斷是否有中斷標志
          throw new InterruptedException();
          /**
          * 該方法是由子類重寫,AQS強制其子類重寫,否則報錯
          * 根據(jù)if中的值判斷是否需要阻塞操作 1代表不需要阻塞 -1代表需要阻塞
          */
      if (tryAcquireShared(arg) < 0)
          doAcquireSharedInterruptibly(arg);//調用AQS共享鎖阻塞操作
  }

/**
 * 獲取同步數(shù)并判斷是否需要喚醒
 * 同步數(shù)state為0,則需要喚醒返回1即不需要阻塞
 * 同步數(shù)state不為1,則不需要喚醒,返回-1后的操作即阻塞
 */
 protected int tryAcquireShared(int acquires) {
     return (getState() == 0) ? 1 : -1;//獲取AQS中的state進行返回是否需要進行阻塞操作
 }

//以共享鎖的方式進行阻塞
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    /**
    * addWaiter方法主要是基于當前線程創(chuàng)建一個等待著并入隊且會創(chuàng)建一個哨兵節(jié)點
    * addWaiter具體細節(jié)和其內部enq初始化隊列方法請轉入AQS分析
    */
    final Node node = addWaiter(Node.SHARED);//以共享鎖創(chuàng)建一個等待者node
    boolean failed = true;
    try {
        for (;;) {//自旋,是否需要阻塞
            final Node p = node.predecessor();//當前線程的前繼節(jié)點
            if (p == head) {//前繼節(jié)點是否為頭節(jié)點
                int r = tryAcquireShared(arg);//嘗試獲取共享鎖即是否需要阻塞1和-1值
                if (r >= 0) {//當其大于等于時,r值只能時1或者-1,滿足該條件時則說明不需要阻塞
                    setHeadAndPropagate(node, r);//設置新的頭結點并釋放共享鎖
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            /**
            * shouldParkAfterFailedAcquire主要是改變前節(jié)點的等待信號量
            * parkAndCheckInterrupt在前者返回TRUE的情況下會直接調用LockSupport.park()進行阻塞
            * 上述兩種方法在AQS分析中可找到詳細解釋
            */
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();//上述兩個條件滿足則代表線程被中斷過
        }
    } finally {
        if (failed)//出現(xiàn)異常且未執(zhí)行for循環(huán)中改變該failed值
            cancelAcquire(node);//取消超時節(jié)點和當前節(jié)點取消喚醒,AQS原理分析中詳細講解
    }
}

//用于子線程調用將同步數(shù)-1
public void countDown() {
    sync.releaseShared(1);//通過內部成員變量sync調用內部Sync類繼承AQS中的釋放方法
}

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {//AQS類中定義強制子類重寫該方法,用于是否需要喚醒被阻塞的線程
        doReleaseShared();//滿足判斷條件則進行正常釋放
        return true;//釋放成功
    }
    return false;//不需要釋放
}

/**
* 主要利用自旋鎖的原理,對state值進行-1
*/
protected boolean tryReleaseShared(int releases) {
    for (;;) {
        int c = getState();//獲取state值
        if (c == 0)//還未開始自減,已為0則代表不能正常釋放
            return false;
        int nextc = c-1;
        if (compareAndSetState(c, nextc))//CAS對state值進行設置新的值
            return nextc == 0;//計數(shù)器是否為0,此狀態(tài)為0代表可以正常釋放
    }
}

/**
 * 釋放共享鎖
 */
private void doReleaseShared() {
    for (;;) {//自旋
        Node h = head;//頭節(jié)點
        if (h != null && h != tail) {//代表可喚醒且不是尾結點
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {//頭節(jié)點的等待狀態(tài)為喚醒信號量
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);//if中cas操作成功,則執(zhí)行該喚醒方法,否則進行自旋或者結束
            }else if (ws == 0 &&//初始化但未被改變時
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))//設置為無條件喚醒
                continue;// loop on failed CAS 該else if中CAS失敗進行自旋
        }
        if (h == head)//loop if head changed 循環(huán)判定頭結點是否發(fā)生變化,實際上是喚醒后會執(zhí)行這里結束自旋
            break;
    }
}

/**
* (1)對信號量節(jié)點即前繼節(jié)點等待值還原
* (2)對于node節(jié)點的后繼節(jié)點不為null直接喚醒或從后往前找尋信號量最靠前的線程進行喚醒
*/
private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;//該節(jié)點等待狀態(tài)即頭結點的信號量
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);//將該節(jié)點的狀態(tài)值設置為0即初始值
    Node s = node.next;//獲取喚醒節(jié)點即node的下一節(jié)點
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)//從后往前查找最靠前的信號量node
            if (t.waitStatus <= 0)//信號量或初始化值
                s = t;
    }
    if (s != null)//找到喚醒節(jié)點
        LockSupport.unpark(s.thread);對該線程進行喚醒
}