在上一章，我们学习了信号量（Semaphore）是如何请求许可证的，下面我们来看看要如何归还许可证。
可以看到当我们要归还许可证时，不论是调用release()或是release(int permits)，都会调用AQS实现的releaseShared(int arg)方法。在releaseShared(int arg)方法中会先调用子类实现的tryReleaseShared(int arg)方法，这个方法会向信号量归还许可证，在归还完毕后，会调用doReleaseShared()方法尝试唤醒信号量等待队列中需要许可证的线程，这也印证了笔者之前所说的线程在归还信号量后，会尝试唤醒等待队列中等待许可证的线程。
那我们来看看信号量（Semaphore）静态内部类Sync实现的tryReleaseShared(int releases)是怎么完成归还许可证，首先会调用getState()获取信号量当前剩余的许可证，加上外部线程归还的许可证数量算出总许可证数量：current + releases，如果能用CAS的方式修改成功，则退出方法，否则一直轮询直到归还成功，这里CAS失败的原因有可能是外部也在请求和归还许可证，可能在执行完代码<1>处后和执行代码<2>处之前，信号量内部的许可证数量已经变了，所以CAS失败。归还信号量成功后就会调用doReleaseShared()，这个方法前面已经讲解过了，这里就不再赘述了。
public class Semaphore implements java.io.Serializable {
//...
abstract static class Sync extends AbstractQueuedSynchronizer {
//...
protected final boolean tryReleaseShared(int releases) {
for (;;) {
int current = getState();//<1>
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))//<2>
return true;
}
}
//...
}
//...
public void release() {
sync.releaseShared(1);
}
//...
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
//...
}
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
//...
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
//...
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
//...
}
下面我们再来看看tryAcquire(long timeout, TimeUnit unit)和tryAcquire(int permits, long timeout, TimeUnit unit)的实现，这两个方法会在给定的时间范围内尝试获取许可证，如果获取成功则返回true，获取失败则返回false。
这两个方法都会调用AQS实现的tryAcquireSharedNanos(int arg, long nanosTimeout)，这个方法其实和先前讲得doAcquireShared(int arg)十分相似，只是多了一个超时返回的功能。
这里笔者简单过一下这个方法的实现：先在代码<1>处算出超时时间，然后封装线程对应的节点Node并将其入队，如果判断节点的前驱节点是头节点，且申请许可证成功，这里会调用setHeadAndPropagate(node, r)将头节点指向当前节点，并尝试唤醒下一个节点对应的线程。如果申请许可证失败，会在<2>处算出还剩多少的阻塞时间nanosTimeout，如果剩余阻塞时间小于等于0，代表线程获取许可证失败，这里会调用<3>处的cancelAcquire(node) 将节点从等待队列中移除，具体的移除逻辑可以看笔者写的ReentrantLock源码解析第二章。如果剩余阻塞时间大于0，则会执行shouldParkAfterFailedAcquire(p, node)将前驱节点的等待状态改为SIGNAL，在第二次循环时，如果前驱节点的状态为SIGNAL，且剩余阻塞时间大于SPIN_FOR_TIMEOUT_THRESHOLD（1000ns），则陷入阻塞，直到被中断抛出异常，或者被唤醒，检查是否能获取许可证，如果不能获取许可证且超时，则会返回false表示在超时时间内没有获取到许可证。
public class Semaphore implements java.io.Serializable {
//...
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 boolean tryAcquire(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
//...
}
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
//...
public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
return tryAcquireShared(arg) >= 0 ||
doAcquireSharedNanos(arg, nanosTimeout);
}
//...
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (nanosTimeout <= 0L)
return false;
final long deadline = System.nanoTime() + nanosTimeout;//<1>
final Node node = addWaiter(Node.SHARED);
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
return true;
}
}
nanosTimeout = deadline - System.nanoTime();//<2>
if (nanosTimeout <= 0L) {
cancelAcquire(node);//<3>
return false;
}
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > SPIN_FOR_TIMEOUT_THRESHOLD)
LockSupport.parkNanos(this, nanosTimeout);
if (Thread.interrupted())
throw new InterruptedException();
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
}
}
//...
}
下面我们对照一下FairSync和NonfairSync，其实NonfairSync基本没有什么实现，都是调用其父类Sync的方法，以非公平的方式竞争许可证也是调用其父类nonfairTryAcquireShared(acquires)方法。而FairSync自身是有实现以公平的方式获取许可证，实现逻辑也非常简单。先判断信号量的等待队列是否有节点，有的话则返回获取失败，如果没有再获取当前的可用许可证数量available，扣去申请的许可证数量available - acquires，用CAS的方式把扣减完的值remaining存放进state，由于扣减的时候可能存在其他线程也在申请/归还许可证，所以available的值并非一直有效，如果在获取available后有其他线程也申请和归还许可证，那么这里的CAS很可能会失败，判断CAS失败后，又会开始新的一轮尝试获取许可证逻辑。
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;
FairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
for (;;) {
if (hasQueuedPredecessors())
return -1;
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
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);
}
}
对照完公平FairSync和非公平NonfairSync的差别后，我们来看看Sync类实现的方法，Sync类的实现其实也不算复杂，主要就下面4个方法，其中：nonfairTryAcquireShared(int acquires)和tryReleaseShared(int releases)先前已经将结果了，下面我们专注：reducePermits(int reductions)和drainPermits()。
abstract static class Sync extends AbstractQueuedSynchronizer {
final int nonfairTryAcquireShared(int acquires) {
//...
}
protected final boolean tryReleaseShared(int releases) {
//...
}
final void reducePermits(int reductions) {
//...
}
final int drainPermits() {
//...
}
}
Sync类实现的的reducePermits(int reductions)的作用是降低许可证数量，比如当双11来临时，淘宝京东可以对一些服务进行扩容和配置升级，使得原本可以承受10W并发量的服务提高到可以承受50W，这里可以在不调用acquire()的前提下，调用release()方法增加信号量的许可证，当双11的压力过去后，需要对服务进行缩容，由50W的并发量回到10W，这里可以用reducePermits(int reductions)降低许可证数量。在这个方法中会先获取当前许可证数量，减去我们要扣除的许可证数量current - reductions，并判断其结果是否溢出，如果溢出则抛出异常，没有溢出用CAS的方式设置最新的许可证数量。
public class Semaphore implements java.io.Serializable {
//...
abstract static class Sync extends AbstractQueuedSynchronizer {
//...
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;
}
}
//...
}
//...
protected void reducePermits(int reduction) {
if (reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}
//...
}
需要注意两点：
- 这个方法的访问权限是protected，如果要使用此方法需要用一个类去继承，并修改此方法的访问权限。
- 这个方法可能导致信号量的剩余许可证数量为负，比如一个信号量原先的许可证数量为10，且被借走了9个许可证，当前许可证数量为1。这时想把许可证数量从原先的10扣降到3，向reducePermits(int reduction)传入7，此时current-reductions=1-7=-6，如果CAS成功，那么信号量目前的许可证数量为-6，不过没关系，如果前面借走的9个许可证最终会归还，信号量的许可证数量最终会回到3。
class MySemaphore extends Semaphore {
public MySemaphore(int permits) {
super(permits);
}
@Override
public void reducePermits(int reduction) {
super.reducePermits(reduction);
}
}
public static void main(String[] args) {
MySemaphore semaphore = new MySemaphore(8);
System.out.println("初始信号量的许可证数量:" + semaphore.availablePermits());
//初始化完信号量后，增加信号量的许可证数量
int add = 2;
semaphore.release(add);
System.out.printf("增加%d个许可证后，许可证数量:%d
", add, semaphore.availablePermits());
//申请9个许可证
int permits = 9;
try {
semaphore.acquire(permits);
System.out.printf("申请%d个许可证后剩余许可证数量:%d
", permits, semaphore.availablePermits());
} catch (InterruptedException e) {
e.printStackTrace();
}
//这里要将原先10个许可证扣除到只剩3个，所以传入7，扣除7个许可证
semaphore.reducePermits(7);
System.out.println("扣除7个许可证数量后，剩余许可证数量:" + semaphore.availablePermits());
//归还原先出借的9个许可证
semaphore.release(permits);
System.out.printf("归还原先出借的%d信号量后，剩余信号量:%d
", permits, semaphore.availablePermits());
}
执行结果：
初始信号量的许可证数量:8 增加2个许可证后，许可证数量:10 申请9个许可证后剩余许可证数量:1 扣除7个许可证数量后，剩余许可证数量:-6 归还原先出借的9信号量后，剩余信号量:3
Sync类实现的drainPermits()可以一次性扣除信号量目前所有的许可证数量并返回，通过这个API，我们可以得知资源目前最大的访问限度。还是拿上一章远程服务为例，判定服务能承受的并发是5000，用于限流的semaphore信号量的最大许可证数量也是5000。假设目前信号量剩余的许可证数量为2000，即有3000个线程正在并发访问远程服务，我们可以通过drainPermits()方法获取剩余的允许访问数量2000，然后创建2000个线程访问远程服务，这个API一般用于计算量大且计算内容比较独立的场景。
public class Semaphore implements java.io.Serializable {
//...
abstract static class Sync extends AbstractQueuedSynchronizer {
//...
final int drainPermits() {
for (;;) {
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
//...
}
//...
public int drainPermits() {
return sync.drainPermits();
}
//...
}
最后，笔者介绍一个Semaphore在JDK1.6.0_17时期的BUG，便结束对Semaphore的源码解析。
当时AQS的setHeadAndPropagate(Node node, int propagate)和releaseShared(int arg) 两个方法的实现是下面这样的，这个代码可能导致队列被阻塞。
private void setHeadAndPropagate(Node node, int propagate) {
setHead(node);
if (propagate > 0 && node.waitStatus != 0) {
Node s = node.next;
if (s == null || s.isShared())
unparkSuccessor(node);
}
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
按照上面代码的实现，会让下面的代码出现队列被阻塞的情况。t1和t2线程用于请求许可证，t3和t4线程用于归还许可证，循环10000000次只是为了增加出现阻塞的概率，现在说说什么样的场景下会出现队列被阻塞的情况。
程序开始时，信号量的许可证数量为0，所以t1和t2只能进入队列等待，t1和t2在队列中的节点对应N1和N2，节点的排序为：head->N1->N2(tail)。t3归还许可证时发现头节点不为null且头节点的等待状态为SIGNAL，于是会调用unparkSuccessor(h)方法唤醒头节点的后继节点N1对应的线程t1，在执行unparkSuccessor(h)的时候会把head的等待状态改为0。
t1被唤醒后获取到许可证，返回剩余许可证数量为0，即之后调用setHeadAndPropagate(Node node, int propagate)方法传入的propagate为0，但尚未调用。此时t4也归还了许可证，但发现head节点的等待状态为0，就不会调用unparkSuccessor(h)。
t1执行setHeadAndPropagate(Node node, int propagate)，将头节点指向自身线程对应的节点N1，虽然此时信号量里有剩余的许可证，但t1原先拿到的propagate为0，所以不会执行unparkSuccessor(node)唤醒t4。
那么新版本的setHeadAndPropagate(Node node, int propagate)和releaseShared(int arg)又是如何保证有许可证被归还时唤醒队列中被阻塞的线程呢？这里其实和PROPAGATE有关，让我们按照新版的setHeadAndPropagate和releaseShared走一遍上面的流程。
t1和t2进入队列中等待，t3归还许可证发现头节点不为null，且头节点等待状态为SIGNAL，于是调用unparkSuccessor(h)方法唤醒头节点的后继节点N1对应的线程t1，在执行unparkSuccessor(h)的时候会把head的等待状态改为0。
t1被唤醒后获取到许可证，返回剩余许可证数量为0，在调用setHeadAndPropagate(Node node, int propagate)之前，t4归还了许可证，发现头节点的等待状态为0，将其改为PROPAGATE。
t1执行setHeadAndPropagate(Node node, int propagate)，获取原先头节点h，并将头节点指向N1，此时虽然propagate为0，但原先头节点h的等待状态<0，可以执行doReleaseShared()唤醒后继节点N2对应的线程t2。
import java.util.concurrent.Semaphore;
public class TestSemaphore {
private static Semaphore sem = new Semaphore(0);
private static class Thread1 extends Thread {
@Override
public void run() {
sem.acquireUninterruptibly();
}
}
private static class Thread2 extends Thread {
@Override
public void run() {
sem.release();
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10000000; i++) {
Thread t1 = new Thread1();
Thread t2 = new Thread1();
Thread t3 = new Thread2();
Thread t4 = new Thread2();
t1.start();
t2.start();
t3.start();
t4.start();
t1.join();
t2.join();
t3.join();
t4.join();
System.out.println(i);
}
}
}
至此，Semaphore的源码解析就到此结束了。笔者在这里并没有全部介绍完所有Semaphore的API，例如：acquireUninterruptibly()和acquireUninterruptibly(int permits)，因为这两个方法实在与之前介绍的acquire()，如果大家能理解清楚前面讲解的内容，这两个API相信对大家不在话下。
本章我们也初次见到AQS内部类Node的不同状态和使用方式，即节点除了独占（Node.EXCLUSIVE），还会有共享的状态（Node.SHARED），这里我们也首次见到等待状态为PROPAGATE的节点，代表传播的意思，通过这个状态，不但可以提升信号量整体的吞吐量，还可以避免高并发场景下节点没有被唤醒的情况。