Semaphore

Semaphore 是 Java 并发包中提供的一个工具类，翻译过来为“信号量”，作用是控制并发线程的数量。

类的结构

先来看一下 Semaphore 的结构：

Semaphore 中有三个个内部类：

• 类 Sync 继承了 AbstractQueuedSynchronizer，重写了 tryReleaseShared 方法，还有一些在 Semaphore 中用到的辅助方法，都是对线程进行控制的
• 类 NonfairSync 继承了 Sync，通过重写 tryAcquireShared 方法实现了非公平的线程竞争机制，这个方法内部是调用了 Sync 的 nonfairTryAcquireShared 方法
• 类 FairSync 继承了 Sync，也是通过重写 tryAcquireShared 方法实现了公平的线程竞争机制

由此可以看出，Semaphore 实际上是通过 AQS 的共享锁来控制线程的。

构造方法

Semaphore 的构造函数对变量 sync 进行了初始化，默认是非公平竞争的，也可以通过指定参数设置为公平竞争，其他所有的方法内部都是调用了 sync 变量的方法。

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

acquire

acquire 用来获取信号量，Semaphore 提供了重载方法，也可以获取多个信号量。

public void acquire() throws InterruptedException { // 获取 1 个信号量    sync.acquireSharedInterruptibly(1);}public void acquire(int permits) throws InterruptedException {    if (permits < 0) throw new IllegalArgumentException(); // 参数判断    sync.acquireSharedInterruptibly(permits); // 获取指定个数的信号量}

acquire 方法内部调用了 sync 的 acquireSharedInterruptibly 方法，这里并没有对这个方法进行重写，所以调用的还是 AbstractQueuedSynchronizer 中的方法，这里就不贴代码了，但是 acquireSharedInterruptibly 方法内部又调用了 tryAcquireShared 方法，由于 Semaphore 类提供了公平和非公平两种竞争机制，所以 tryAcquireShared 也有两种不同的实现。

来看一下两种获取锁的方法。

tryAcquireShared

先来看一下非公平的 tryAcquireShared，这个方法是内部类 NonfairSync 中的：

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

继续看 nonfairTryAcquireShared，这个方法是 Sync 提供的：

final int nonfairTryAcquireShared(int acquires) {    for (;;) { // 循环直到获取成功        int available = getState(); // 获取当前 state，在这里就是信号量        int remaining = available - acquires; // 减去获取的信号量后剩余的信号量        // 如果信号量小于 0（获取失败） 或者更新信号量成功，返回剩余信号量        if (remaining < 0 ||            compareAndSetState(available, remaining))            return remaining;    }}

再看公平的 tryAcquireShared，这个方法是内部类 FairSync 中的：

protected int tryAcquireShared(int acquires) {    for (;;) {        // 先判断在当前线程之前是否有线程正在 acquire，如果有返回 -1 表示获取失败        if (hasQueuedPredecessors())            return -1;        int available = getState();        int remaining = available - acquires;        if (remaining < 0 ||            compareAndSetState(available, remaining))            return remaining;    }}

相对于非公平的 nonfairTryAcquireShared，公平的 tryAcquireShared 先判断在当前线程之前是否有线程正在 acquire，如果有就直接返回 -1 表示 tryAcquire 失败了，这就是公平的体现。

acquire 还提供了忽略中断的 acquireUninterruptibly，这里就不展开来说了。

release

release 方法用来释放信号量，同样的，Semaphore 提供了重载方法，可以释放多个信号量。

public void release() {    sync.releaseShared(1);}public void release(int permits) {    if (permits < 0) throw new IllegalArgumentException();    sync.releaseShared(permits);}

和 acquire 一样，release 方法调用了 AbstractQueuedSynchronizer 中的 releaseShared 方法，releaseShared 方法内部又调用了 tryReleaseShared 方法，这个方法由子类 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;    }}

tryReleaseShared 的逻辑比较简单，将信号量归还，CAS 更新 state 即可。

Semaphore 还提供了 tryAcquire 方法以及一些辅助方法，这里不再赘述。

总结

Semaphore 提供了线程的控制方案，对线程的竞争提供了公平和非公平的方式。

应用

import java.util.concurrent.Semaphore;public class SemaphoreTest {    private static final int numOfThreads = 5; // 线程数    private static final int sleepTime = 3000; // 睡眠时间    public static void main(String[] args) {        Semaphore semaphore = new Semaphore(numOfThreads);        System.out.println("停车场一共有 " + numOfThreads + " 个停车位");        for (int i = 0; i < 2 * numOfThreads; i++) {            new Thread(new Runnable() {                @Override                public void run() {                    try {                        semaphore.acquire();                        System.out.println(Thread.currentThread().getName() + " 停车");                        Thread.sleep(sleepTime);                        System.out.println(Thread.currentThread().getName() + " 开走了");                        semaphore.release();                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                }            }).start();        }    }}

输出结果为：

停车场一共有 5 个停车位Thread-2 停车Thread-0 停车Thread-1 停车Thread-4 停车Thread-3 停车Thread-0 开走了Thread-2 开走了Thread-8 停车Thread-7 停车Thread-1 开走了Thread-4 开走了Thread-3 开走了Thread-9 停车Thread-6 停车Thread-5 停车Thread-7 开走了Thread-8 开走了Thread-9 开走了Thread-6 开走了Thread-5 开走了

CountDownLatch、CyclicBarrier 和 Semaphore

• CountDownLatch 由一类线程控制另一类线程，CyclicBarrier 是一类线程都执行到了 await 方法后再继续执行，Semaphore 则是控制同时执行的线程的数量
• CountDownLatch 主要通过 await 方法和 countDown 方法控制，CyclicBarrier 只通过 await 方法，Semaphore 通过 acquire 方法和 release 方法