简介
Semaphore（信号量）是juc包下的一个工具类，主要是用来控制同时访问公共资源的线程数，这个数量在Semaphore中叫做凭证数（acquires），内部是采用AbstractQueuedSynchronizer去实现的，AbstractQueuedSynchronizer是一个同步队列，juc包下有许多工具类都依赖于该类去实现功能，例如ReentrantReadWriteLock、CountDownLatch、Semaphore等，那么我们接下来就具体看下Semaphore的具体使用方法。
案例
首先我们设定一个背景，假如现在我们去银行取钱，银行的窗口有四个，然后现在有很多人都在等着办理业务，但是窗口只有四个，所以同时能进行业务办理的只有四个，每办理完一个释放一个可用窗口然后才能进行下一个的业务办理，这个场景就可以用Semaphore来实现。
public class SemaphoreTest {
private static final int MAX_COUNT = 4;
public static void main(String[] args) throws InterruptedException {
ExecutorService executorService = Executors.newFixedThreadPool(10);
Semaphore semaphore = new Semaphore(MAX_COUNT, true);
int personNumber = 20;
for (int i = 0; i < personNumber; i++) {
executorService.execute(() -> {
try {
//尝试获取资源
semaphore.acquire(1);
//....办理业务...//
LockSupport.parkNanos(1000 * 1000 * 1000);
//释放资源
semaphore.release(1);
System.out.println("办理完毕");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
}
源码分析（acquire方法）
接下来我们具体分享下Semaphore的原理，Semaphore主要就是两个方法一个是获取凭证一个是释放凭证资源，我们先来分析下acquire方法。
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)//尝试获取许可
doAcquireSharedInterruptibly(arg);//获取许可失败进入该方法
}
这里我们可以看出acquire方法内部调用的是sync类的acquireSharedInterruptibly方法，而acquireSharedInterruptibly方法中存在两个方法的调用，首先调用的是tryAcquireShared方法，该方法功能是尝试获取凭证，如果方法返回值小于0则进行acquireSharedInterruptibly方法。
protected int tryAcquireShared(int acquires) {
for (;;) {
if (hasQueuedPredecessors())
return -1;
int available = getState();//获取当前可用的凭证数，state是由validate修饰的，保证变量的可见性。
int remaining = available - acquires;//计算出剩余凭证数量
if (remaining < 0 ||
compareAndSetState(available, remaining))//凭证数小于零或者是cas替换凭证数成功则直接结束该方法。
return remaining;
}
}
这里我看到tryAcquireShared方法，内部是采用自旋重试方式进行锁获取的，单次循环的逻辑可以看上述代码，先是调用hasQueuedPredecessors方法（这个方法的功能是查看当前是否存在排队的线程，如果存在排队的线程且不是当前线程则返回true，当前循环直接终止并返回-1），这个方法只存在公平模式中，非公平模式没有这段判断逻辑。
然后再获取state值也就是可用凭证数，判断其state是否可用，可用进行cas原子替换操作，将计算后的可用凭证数值赋值给state，执行完毕返回remaining值。
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);//创建SHARED类型node节点
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();//获取当前节点的上一个节点
if (p == head) {//如果上一个节点为head，进入if业务逻辑
int r = tryAcquireShared(arg);//尝试获取凭证
if (r >= 0) {//获取成功，并且剩余凭证数大于零进入if业务逻辑
setHeadAndPropagate(node, r);//通知并且重置head节点
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
当tryAcquireShared方法获取凭证数失败后，则会进入上述方法doAcquireSharedInterruptibly中，首先为当前线程创建一个node等待节点，并且添加至aqs队列中，如果当前node节点的上一个节点非head，且上一个节点也是等待状态，则当前线程执行LockSupport.park进行长时间等待直到有可用凭证数为止，如果上一个节点是head节点则进行再一次的尝试获取凭证数，如果获取成功则直接终止循环并且将node节点状态置为已取消，如果获取失败则进行再次循环执行相同的业务逻辑。
这里核心注意下两个方法setHeadAndPropagate、shouldParkAfterFailedAcquire。
private void setHeadAndPropagate(Node node, int propagate) {
Node h = head; // Record old head for check below
setHead(node);
if (propagate > 0 || h == null || h.waitStatus < 0 ||
(h = head) == null || h.waitStatus < 0) {
Node s = node.next;
if (s == null || s.isShared())
doReleaseShared();
}
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
setHeadAndPropagate这个方法只会存在Share模式下，如果是独占则不会存在该方法，该方法的作用就是当可用凭证数大于0的时候进行往后唤醒等待的共享节点。
shouldParkAfterFailedAcquire该方法是判断当前节点是否应该被挂起，如果前驱节点为signal则直接挂起当前线程，如果前驱节点为cancelled则一直往上查找直至找到状态不为cancelled为止并且将前置节点的状态cas替换为signal。
waitStatus 5 个状态值的含义：
cancelled(1)：该节点的线程可能由于超时或被中断而处于被取消状态，一旦处于这个状态，节点状态将一直处于cancelled，因此应该从队列中移除。
signal(-1)：当前节点为 signal 时，后继节点会被挂起，因此在当前节点释放锁或被取消之后必须被唤醒(unparking)其后继结点。
condition(-2)：该节点的线程处于等待条件状态，不会被当作是同步队列上的节点,直到被唤醒(signal)，设置其值为 0,重新进入阻塞状态。
propagate(-3) ：下一个 acquireShared 无条件传播。
0：初始化状态。
源码分析（release方法）
acquire分析完之后我们再看下release方法。
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
releaseShared方法是属于sync的内部方法，由semaphore.release进行调用，方法内部先调用tryReleaseShared方法，如果成功则调用doReleaseShared方法，我们先看下releaseShared方法内部的tryReleaseShared方法。
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方法功能很简单，该方法就是将state加上释放的releases值然后再cas赋值给state
变量。
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
doReleaseShared该方法主要功能就是尝试唤醒head的后继节点，如果后继节点存在且是signal状态则进行唤醒，这里需要关注的是unparkSuccessor方法，unparkSuccessor方法内部对head节点的后继节点进行了二次判断，如果后继节点不存在或是waitStatus为取消状态则从队列尾部开始向前查找知道节点状态不是取消为止，然后进行唤醒。
总结
至此我们已经将Semaphore的acquire方法以及release方法的源码简单的进行了分析，Semaphore可以用来控制访问公共资源的线程数，其内部是基于aqs实现的，aqs内部维护的state变量表示当前还可获取许可证的资线程数，感兴趣的同学可以去深入看下其他的方法，例如带超时时间的tryAcquire方法。
