JDK8 Semaphore源码

信号量。持有一些许可数，线程想要执行就要请求许可，请求不到许可则会被阻塞

package java.util.concurrent;
import java.util.Collection;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * 信号量。持有一些许可数，线程想要执行就要请求许可，请求不到许可则会被阻塞
 */
public class Semaphore implements java.io.Serializable {
    private final Sync sync;
    abstract static class Sync extends AbstractQueuedSynchronizer {
        /**
         * 构造
         * @param permits 许可数
         */
        Sync(int permits) {
            setState(permits);
        }
        final int getPermits() {
            return getState();
        }

        /**
         * 非公平获取共享许可
         * 直接就去获取许可，不排队
         * @param acquires 许可数
         * @return 剩余许可数
         */
        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                // 可用许可数
                int available = getState();
                // 剩余许可数
                int remaining = available - acquires;
                // 如果剩余许可小于0 或者 cas设置成功，返回剩余许可数
                if (remaining < 0 ||
                        compareAndSetState(available, remaining))
                    return remaining;
            }
        }

        /**
         * 重写父类，尝试释放共享
         * @param releases 释放的许可数
         * @return 是否成功释放
         */
        protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                // 当前许可数
                int current = getState();
                // 还许可数
                int next = current + releases;
                // release小于0
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                // cas设置剩余许可
                if (compareAndSetState(current, next))
                    return true;
            }
        }

        /**
         * 减少许可
         * @param reductions 减少的数量
         */
        final void reducePermits(int reductions) {
            for (;;) {
                int current = getState();
                int next = current - reductions;
                if (next > current) // underflow
                    throw new Error("Permit count underflow");
                if (compareAndSetState(current, next))
                    return;
            }
        }

        /**
         * 清空许可
         * @return 0
         */
        final int drainPermits() {
            for (;;) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
    }

    /**
     * NonFair version
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;

        NonfairSync(int permits) {
            super(permits);
        }

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

    /**
     * Fair version
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;

        FairSync(int permits) {
            super(permits);
        }

        /**
         * 判断一次获取许可是否可以成功
         * 会判断是否需要排队，不需要的话直接去获取许可
         * 需要排队的话，不再获取许可，直接返回获取失败
         * @param acquires 想要获取的许可数
         * @return 是否成功
         */
        protected int tryAcquireShared(int acquires) {
            for (;;) {
                // 如果线程需要排队，则直接返回-1，尝试获取失败
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                        compareAndSetState(available, remaining))
                    return remaining;
            }
        }
    }

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

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

    /**
     * 可中断地获取
     * @throws InterruptedException 中断异常
     */
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    /**
     * 不响应中断地获取
     */
    public void acquireUninterruptibly() {
        sync.acquireShared(1);
    }

    /**
     * 尝试获取共享
     * @return 是否成功
     */
    public boolean tryAcquire() {
        return sync.nonfairTryAcquireShared(1) >= 0;
    }

    /**
     * 带时限地获取
     * @param timeout 超时时间
     * @param unit 单位
     * @return 是否成功
     * @throws InterruptedException 中断异常
     */
    public boolean tryAcquire(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    /**
     * 释放许可
     */
    public void release() {
        sync.releaseShared(1);
    }

    /**
     * 可中断地获取许可
     * @param permits 许可数
     * @throws InterruptedException 中断异常
     */
    public void acquire(int permits) throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireSharedInterruptibly(permits);
    }

    /**
     * 不响应中断地获取
     */
    public void acquireUninterruptibly(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.acquireShared(permits);
    }

    /**
     * 尝试获取
     * @param permits 许可数
     * @return 是否
     */
    public boolean tryAcquire(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.nonfairTryAcquireShared(permits) >= 0;
    }

    /**
     * 带时限地获取
     * @param timeout 超时时间
     * @param unit 单位
     * @return 是否成功
     * @throws InterruptedException 中断异常
     */
    public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
            throws InterruptedException {
        if (permits < 0) throw new IllegalArgumentException();
        return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
    }

    /**
     * 释放许可
     */
    public void release(int permits) {
        if (permits < 0) throw new IllegalArgumentException();
        sync.releaseShared(permits);
    }

    /**
     * 可用许可数
     * @return 许可数
     */
    public int availablePermits() {
        return sync.getPermits();
    }

    /**
     * 清空许可
     */
    public int drainPermits() {
        return sync.drainPermits();
    }

    /**
     * 减少许可
     * @param reduction 减少的数量
     */
    protected void reducePermits(int reduction) {
        if (reduction < 0) throw new IllegalArgumentException();
        sync.reducePermits(reduction);
    }

    /**
     * 是否公平
     */
    public boolean isFair() {
        return sync instanceof FairSync;
    }

    /**
     * 队列中是否有线程
     * @return 是否
     */
    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    /**
     * 获取同步等待队列的长度
     */
    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    /**
     * 同步等待队列中线程集合
     */
    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    
    public String toString() {
        return super.toString() + "[Permits = " + sync.getPermits() + "]";
    }
}