import java.util.concurrent.Semaphore;

Semaphore semaphore = new Semaphore(n);

try {
    semaphore.acquire(); // 獲取信號量，如果沒有可用的許可證，線程將被阻塞
    // 訪問共享資源的代碼
} catch (InterruptedException e) {
    // 處理中斷異常
} finally {
    semaphore.release(); // 釋放信號量，增加一個許可證
}

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

  public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;
 
        NonfairSync(int permits) {
            // permits 即 state
 
            super(permits);
        }
 
        // Semaphore 方法, 方便閱讀, 放在此處
 
        public void acquire() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }
 
        // AQS 繼承過來的方法, 方便閱讀, 放在此處
 
        public final void acquireSharedInterruptibly(int arg)
                throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            if (tryAcquireShared(arg) < 0)
                doAcquireSharedInterruptibly(arg);
        }
 
        // 嘗試獲得共享鎖
 
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
 
        // Sync 繼承過來的方法, 方便閱讀, 放在此處
 
        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (
                    // 如果許可已經用完, 返回負數(shù), 表示獲取失敗, 進入 doAcquireSharedInterruptibly
 
                        remaining < 0 ||
 
                                // 如果 cas 重試成功, 返回正數(shù), 表示獲取成功
 
                                compareAndSetState(available, remaining)
                ) {
                    return remaining;
                }
            }
        }
 
        // AQS 繼承過來的方法, 方便閱讀, 放在此處
 
        private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
            final Node node = addWaiter(Node.SHARED);
            boolean failed = true;
            try {
                for (;;) {
                    final Node p = node.predecessor();
                    if (p == head) {
                        // 再次嘗試獲取許可
 
                        int r = tryAcquireShared(arg);
                        if (r >= 0) {
                            // 成功后本線程出隊（AQS）, 所在 Node設置為 head
 
                            // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一個節(jié)點 unpark
 
                            // 如果 head.waitStatus == 0 ==> Node.PROPAGATE
 
                            // r 表示可用資源數(shù), 為 0 則不會繼續(xù)傳播
 
                            setHeadAndPropagate(node, r);
                            p.next = null; // help GC
 
                            failed = false;
                            return;
                        }
                    }
                    // 不成功, 設置上一個節(jié)點 waitStatus = Node.SIGNAL, 下輪進入 park 阻塞
 
                    if (shouldParkAfterFailedAcquire(p, node) &&
 
                            parkAndCheckInterrupt())
                        throw new InterruptedException();
                }
            } finally {
                if (failed)
                    cancelAcquire(node);
            }
        }
 
        // Semaphore 方法, 方便閱讀, 放在此處
 
        public void release() {
            sync.releaseShared(1);
        }
 
        // AQS 繼承過來的方法, 方便閱讀, 放在此處
 
        public final boolean releaseShared(int arg) {
            if (tryReleaseShared(arg)) {
                doReleaseShared();
                return true;
            }
            return false;
        }
 
        // Sync 繼承過來的方法, 方便閱讀, 放在此處
        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");
                if (compareAndSetState(current, next))
                    return true;
            }
        }
    }