Semaphore 源码 - 技术栈

成员变量

java 复制代码

private final Sync sync;

构造方法

java 复制代码

// 默认非公平，指定许可数量
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

// 指定许可+公平/非公平模式
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

acquire

java 复制代码

// 获取1个许可，可中断，许可不足则阻塞
public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

acquireSharedInterruptibly

java 复制代码

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    // 线程中断直接抛异常
    if (Thread.interrupted())
        throw new InterruptedException();
    // 调用子类Sync实现的tryAcquireShared
    if (tryAcquireShared(arg) < 0)
        // 获取失败，进入共享阻塞队列挂起线程，与 CountdonwLatch 一致
        doAcquireSharedInterruptibly(arg);
}

tryAcquireShared

返回 ≥0：拿到许可，方法直接返回，不阻塞；
返回 <0：无许可，执行doAcquireSharedInterruptibly阻塞线

java 复制代码

int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
}

final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        // 剩余许可<0：返回负数，阻塞；否则CAS修改state返回剩余值
        if (remaining < 0 || compareAndSetState(available, remaining))
            return remaining;
    }
}

release

java 复制代码

public void release() {
    sync.releaseShared(1);
}

releaseShared

java 复制代码

public final boolean releaseShared(int arg) {
    // 调用Sync实现的tryReleaseShared，更新state许可数
    if (tryReleaseShared(arg)) {
        // 释放成功，唤醒阻塞队列里等待许可的线程，与 CountdownLatch 一致
        doReleaseShared();
        return true;
    }
    return false;
}

tryReleaseShared

java 复制代码

protected final boolean tryReleaseShared(int releases) {
    for (;;) {
        int current = getState();
        int next = current + releases;
        // 安全校验：防止无限release导致int溢出
        if (next < current)
            throw new Error("Maximum permit count exceeded");
        if (compareAndSetState(current, next))
            return true;
    }
}

总结

new Semaphore(3) → NonfairSync 构造 → setState (3)；
acquire() → sync.acquireSharedInterruptibly (1) → nonfairTryAcquireShared (1)；
返回 state - 1 ≥ 0，则获取成功不阻塞，否则挂起线程等待唤醒；
release() → sync.releaseShared (1) → tryReleaseShared (1)；
state + 1，释放成功，唤醒队列等待线程（无则无操作）