// 默認(rèn)使用非公平鎖實(shí)現(xiàn)
 public Semaphore(int permits) {
     sync = new NonfairSync(permits);
 }
 ?
 public Semaphore(int permits, boolean fair) {
     sync = fair ? new FairSync(permits) : new NonfairSync(permits);
 }

 // Semaphore.java
 public void acquire() throws InterruptedException {
     sync.acquireSharedInterruptibly(1);
 }

 // AbstractQueuedSynchronizer.java
 public final void acquireSharedInterruptibly(int arg)
         throws InterruptedException {
     // 如果線程是中斷狀態(tài)，拋出異常
     if (Thread.interrupted())
         throw new InterruptedException();
     // 嘗試獲取共享資源
     if (tryAcquireShared(arg) < 0)
         doAcquireSharedInterruptibly(arg);
 }

 // NonfairSync
 protected int tryAcquireShared(int acquires) {
     return nonfairTryAcquireShared(acquires);
 }

 // Sync
 final int nonfairTryAcquireShared(int acquires) {
     for (;;) {
         int available = getState();
         int remaining = available - acquires;
         if (remaining < 0 ||
             compareAndSetState(available, remaining))
             return remaining;
     }
 }

 // AbstractQueuedSynchronizer.java
 protected final boolean compareAndSetState(int expect, int update) {
     // See below for intrinsics setup to support this
     return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
 }

 // AbstractQueuedSynchronizer.java
 // 在隊(duì)尾新建Node對(duì)象并添加
 private Node addWaiter(Node mode) {
     Node node = new Node(Thread.currentThread(), mode);
     // Try the fast path of enq; backup to full enq on failure
     Node pred = tail;
     if (pred != null) {
         node.prev = pred;
         if (compareAndSetTail(pred, node)) {
             pred.next = node;
             return node;
         }
     }
     enq(node);
     return node;
 }

 // AbstractQueuedSynchronizer.java
 private void doAcquireSharedInterruptibly(int arg)
     throws InterruptedException {
     // 將當(dāng)前線程添加到等待隊(duì)列
     final Node node = addWaiter(Node.SHARED);
     boolean failed = true;
     try {
         // for循環(huán)自旋
         for (;;) {
             // 獲取node的前一個(gè)節(jié)點(diǎn)
             final Node p = node.predecessor();
             // 如果前一個(gè)節(jié)點(diǎn)是頭節(jié)點(diǎn)
             if (p == head) {
                 // 嘗試獲取鎖
                 int r = tryAcquireShared(arg);
                 if (r >= 0) {
                     // 獲取鎖成功，更新node信息設(shè)置為頭節(jié)點(diǎn)，并通知其他節(jié)點(diǎn)
                     setHeadAndPropagate(node, r);
                     p.next = null; // help GC
                     failed = false;
                     return;
                 }
             }
             // 判斷是否需要阻塞線程，設(shè)置waitStatus并阻塞
             if (shouldParkAfterFailedAcquire(p, node) &&
                 parkAndCheckInterrupt())
                 throw new InterruptedException();
         }
     } finally {
         if (failed)
             cancelAcquire(node);
     }
 }

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node);
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

protected final boolean tryReleaseShared(int releases) {
    for (;;) {
        int current = getState();
        int next = current + releases;
        if (next < current) // overflow
            throw new Error("Maximum permit count exceeded");
        // 通過CAS更新許可證數(shù)量
        if (compareAndSetState(current, next))
            return true;
    }
}

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}
// 許可證數(shù)量更新完成后，調(diào)用該方法喚醒線程
private void doReleaseShared() {
    // 自旋
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                // 喚醒后繼節(jié)點(diǎn)線程搶占許可證
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}