public static void main(String[] args) {
    Semaphore semaphore = new Semaphore(5);
    for (int i = 0; i < 10; i++){
        int num = i;
        new Thread(()->{
            System.out.println("線程"+num+"初始化!");
            try {
                semaphore.acquire();
                System.out.println("線程"+num+"拿到了鎖執(zhí)行權！");
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("------------------線程"+num+"被喚醒執(zhí)行!-----------------");
            semaphore.release();
        }).start();
    }
    System.out.println("main 線程執(zhí)行!");
}

 /**
  * Semaphore一個參數(shù)值容量,使用非公平NonfairSync類去實例化Sync繼承的AQS中的原子變量state值
  */
  public Semaphore(int permits) {
      sync = new NonfairSync(permits);
  }
  /**
  * Semaphore采用兩個參數(shù),一個容量和是否使用公平或非公平標記來初始化Sync繼承AQS中的原子變量state值
  */
  public Semaphore(int permits, boolean fair) {
      sync = fair ? new FairSync(permits) : new NonfairSync(permits);
  }

/**
* 暴露給外部用于是否阻塞調用的API
* 其內部是Semaphore內部類(Sync)變量sync去調用acquireSharedInterruptibly
*/
public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

/**
* AQS類中確定獲取共享鎖和是否阻塞
*/
public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted())//判斷執(zhí)行線程是否有中斷標記
        throw new InterruptedException();
    /**
    * AQS定義了共享鎖方法并強制子類去重寫該方法(模板模式)
    * 由其子類NonfairSync繼承內部類Sync,Sync繼承于AQS類,最終由NoneFairSync去重寫
    * NoneFairSync又調用了父類Sync中的nonfairTryAcquireShared方法確定是否需要阻塞
    */
    if (tryAcquireShared(arg) < 0)//嘗試獲取共享鎖
        doAcquireSharedInterruptibly(arg);//在未標記中斷前提下,是否需要真正阻塞
}
NoneFairSync類：繼承于Semaphore中的內部類Sync
protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
}
Sync類：
//自旋的模式對state進行-1并返回state-1后的值
final int nonfairTryAcquireShared(int acquires) {
    /**
    * (1)自旋保證本次對state進行-1
    * (2)state-1后的值小于0的情況下對state進行CAS設置新的值
    */
    for (;;) {
        int available = getState();//獲取state值
        int remaining = available - acquires;//當前線程對其-1
        //如果state-1后的值小于0代表無容量可用
        //如果state-1后的值大于等于0,則代表共享鎖還有位置可用,并設置新的state值
        if (remaining < 0 || compareAndSetState(available, remaining))
            return remaining;//返回state-1后的值
    }
}

/**
 * AQS中定義的是否阻塞方法
 * 如果在自旋過程中獲取到了共享鎖,則不進行阻塞,這也是非公平的原因之一
 * 如果在自旋中未獲取到共享鎖則shouldParkAfterFailedAcquire進行更改等待狀態(tài)
 * 在成功改變等待線程信號量后再調用parkAndCheckInterrupt是否阻塞
 * 上述的parkAndCheckInterrupt在被喚醒之前的一段時間內,如果存在中斷標記則會拋出異常,否則正常執(zhí)行
 */
 private void doAcquireSharedInterruptibly(int arg)
         throws InterruptedException {
     final Node node = addWaiter(Node.SHARED);//以共享鎖模式創(chuàng)建隊列
     boolean failed = true;
     try {
         for (;;) {//自旋獲取共享鎖或阻塞
             final Node p = node.predecessor();//獲取當前線程的前繼節(jié)點
             if (p == head) {//前繼節(jié)點是否為頭節(jié)點
                 int r = tryAcquireShared(arg);//嘗試再次獲取共享鎖
                 if (r >= 0) {//獲取到了共享鎖
                     setHeadAndPropagate(node, r);//設置新的頭節(jié)點和喚醒后繼節(jié)點
                     p.next = null; // help GC
                     failed = false;//不需要執(zhí)行婁底的cancelAcquire方法
                     return;
                 }
             }
             /**
             * shouldParkAfterFailedAcquire改變前繼節(jié)點的等待狀態(tài)信號量
             * parkAndCheckInterrupt真正阻塞該線程,使用LockSupport的park方法
             */
             if (shouldParkAfterFailedAcquire(p, node) &&
                 parkAndCheckInterrupt())//改變等前繼節(jié)點的等待狀態(tài)信號量和阻塞該線程
                 throw new InterruptedException();
         }
     } finally {
         if (failed)//是否需要執(zhí)行保底方法
         //當該線程有中斷標記或不需要阻塞時發(fā)生異常取消獲取鎖和過濾超時節(jié)點
             cancelAcquire(node);
     }
 }

 private void setHeadAndPropagate(Node node, int propagate) {
   Node h = head; // Record old head for check below
   setHead(node);
   /**
    * propagate > 0表示可以嘗試喚醒node結點的后繼結點,可能是-3那個線程進行導致其大于0
    * (h = head) == null || h.waitStatus < 0(此時的h被重新賦值)可能會引起沒必要的喚醒操作
    * 比如線程A任務結束后釋放許可,但是線程B任務還沒結束,此時線程C獲取到許可走到這里
    * 執(zhí)行完上面的setHead后,然后 h = head 即h執(zhí)行線程C的結點,
    * 而線程C對應的結點的 waitStatus = SIGNAL，所以也會執(zhí)行doReleaseShared喚醒線程D
    * 線程D喚醒后接著去執(zhí)行 doAcquireSharedInterruptibly 中的for循環(huán)，
    * 執(zhí)行tryAcquireShared去拿許可證的時候發(fā)現(xiàn)是小于0,后面繼續(xù)走掛起方法去掛起線程D
    */
   if (propagate > 0 || h == null || h.waitStatus < 0 ||
       (h = head) == null || h.waitStatus < 0) {
       Node s = node.next;
       if (s == null || s.isShared())
           doReleaseShared();//喚醒等待中的線程
   }
 }

/**
 * 暴露給外部調用釋放API
 * Semaphore內部核心成員變量sync調用AQS中的releaseShared方法進行釋放喚醒
 */
 public void release() {
      sync.releaseShared(1);//調用AQS的釋放并喚醒方法
  }
  AQS類：
  public final boolean releaseShared(int arg) {
      if (tryReleaseShared(arg)) {//強制子類Sync重寫該方法,模板模式
          doReleaseShared();//調用AQS自身釋放共享鎖
          return true;
      }
      return false;
  }
  Sync類：強制重寫父類AQS中的嘗試釋放鎖方法
  protected final boolean tryReleaseShared(int releases) {
      for (;;) {//自旋操作來喚醒
          int current = getState();//獲取state值
          int next = current + releases;//將state值+1
          if (next < current) //Integer.MAX是否達到最大,防止溢出如最大數(shù)+1變?yōu)樨摂?shù)
              throw new Error("Maximum permit count exceeded");
          if (compareAndSetState(current, next))//CAS改變state值
              return true;
      }
  }

/**
 * 嘗試喚醒等待線程
 * (1)正常喚醒頭結點的后繼節(jié)點線程
 * (2)可能伴隨著多個共享鎖被釋放,為了防止空閑許可浪費,會喚醒頭節(jié)點的后繼節(jié)點的后繼節(jié)點
 */
 private void doReleaseShared() {
     for (;;) {
         Node h = head;//獲取隊列中的頭結點
         if (h != null && h != tail) {//判斷隊列中是否還有等待線程
             int ws = h.waitStatus;//獲取頭結點的等待狀態(tài)
             if (ws == Node.SIGNAL) {//可喚醒狀態(tài)
                 if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//將頭結點等待狀態(tài)設置為0
                     continue;//改變頭結點等待狀態(tài)失敗,則跳過本次操作,自旋再次設置
                 unparkSuccessor(h);//在可喚醒狀態(tài)下且改變頭節(jié)點等待狀態(tài)成功的前提下進行喚醒后繼節(jié)點
             }
             /**
             * ws等于0,然后設置waitStatus為Node.PROPAGATE,表示在自旋過程同時有多個鎖都在被釋放
             * 線程A執(zhí)行上面的cas操作將頭結點等待狀態(tài)設置為0
             * 此時的線程B剛好在執(zhí)行上面if不滿足時則執(zhí)行else if邏輯,將頭結點狀態(tài)設置為-3,
             * 主要是方便被喚醒線程自旋執(zhí)行doAcquireSharedInterruptibly中的setHeadAndPropagate方法
             * 即表示要喚醒head后繼結點的后繼結點
             * waitStatus=PROPAGATE就表示要喚醒head后繼結點的后繼結點
             * 線程A和B都釋放許可了,如果有多個等待線程在等待喚醒,在setHeadAndPropagate方法中會有邏輯判斷
             * 防止已經(jīng)有2張許可卻只有線程C拿到許可,線程D還在傻乎乎的等線程C釋放許可來喚醒線程D
             else if (ws == 0 &&
                      !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                 continue;//CAS設置失敗,自旋重新設置
         }
         if (h == head)//結束死循環(huán)
             break;
     }
 }