public static void main(String[] args) {
        // 1. 創(chuàng)建 semaphore 對象
        Semaphore semaphore = new Semaphore(2);
        // 2. 10個線程同時(shí)運(yùn)行
        for (int i = 0; i < 8; i++) {
            new Thread(() -> {
                // 3. 獲取許可
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    log.debug("running...");
                    sleep(1);
                    log.debug("end...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 4. 釋放許可
                    semaphore.release();
                }
            }).start();
        }
    }

// acquire() -> sync.acquireSharedInterruptibly(1)，可中斷
public final void acquireSharedInterruptibly(int arg) {
    if (Thread.interrupted())
        throw new InterruptedException();
    // 嘗試獲取通行證，獲取成功返回 >= 0的值
    if (tryAcquireShared(arg) < 0)
        // 獲取許可證失敗，進(jìn)入阻塞
        doAcquireSharedInterruptibly(arg);
}

// tryAcquireShared() -> nonfairTryAcquireShared()
// 非公平，公平鎖會在循環(huán)內(nèi) hasQueuedPredecessors()方法判斷阻塞隊(duì)列是否有臨頭節(jié)點(diǎn)(第二個節(jié)點(diǎn))
final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        // 獲取 state ，state 這里【表示通行證】
        int available = getState();
        // 計(jì)算當(dāng)前線程獲取通行證完成之后，通行證還剩余數(shù)量
        int remaining = available - acquires;
        // 如果許可已經(jīng)用完, 返回負(fù)數(shù), 表示獲取失敗,
        if (remaining < 0 ||
            // 許可證足夠分配的，如果 cas 重試成功, 返回正數(shù), 表示獲取成功
            compareAndSetState(available, remaining))
            return remaining;
    }
}

private void doAcquireSharedInterruptibly(int arg) {
    // 將調(diào)用 Semaphore.aquire 方法的線程，包裝成 node 加入到 AQS 的阻塞隊(duì)列中
    final Node node = addWaiter(Node.SHARED);
    // 獲取標(biāo)記
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            // 前驅(qū)節(jié)點(diǎn)是頭節(jié)點(diǎn)可以再次獲取許可
            if (p == head) {
                // 再次嘗試獲取許可，【返回剩余的許可證數(shù)量】
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // 成功后本線程出隊(duì)（AQS）, 所在 Node設(shè)置為 head
                    // r 表示【可用資源數(shù)】, 為 0 則不會繼續(xù)傳播
                    setHeadAndPropagate(node, r); 
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            // 不成功, 設(shè)置上一個節(jié)點(diǎn) waitStatus = Node.SIGNAL, 下輪進(jìn)入 park 阻塞
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        // 被打斷后進(jìn)入該邏輯
        if (failed)
            cancelAcquire(node);
    }
}

// release() -> releaseShared()
public final boolean releaseShared(int arg) {
    // 嘗試釋放鎖
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }    
    return false;
}

protected final boolean tryReleaseShared(int releases) {    
    for (;;) {
        // 獲取當(dāng)前鎖資源的可用許可證數(shù)量
        int current = getState();
        int next = current + releases;
        // 索引越界判斷
        if (next < current)            
            throw new Error("Maximum permit count exceeded");        
        // 釋放鎖
        if (compareAndSetState(current, next))            
            return true;    
    }
}

// 喚醒
private void doReleaseShared() {
    // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一個節(jié)點(diǎn) unpark	
    // 如果 head.waitStatus == 0 ==> Node.PROPAGATE    
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                // 防止 unparkSuccessor 被多次執(zhí)行
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;
                // 喚醒后繼節(jié)點(diǎn)
                unparkSuccessor(h);
            }
            // 如果已經(jīng)是 0 了，改為 -3，用來解決傳播性
            else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;
        }
        if (h == head)
            break;
    }
}