JDK 源码解析 —— Semaphore

零. 简介
这是一个用来对并发计数的信号量，并发量超过一定数值则只能等待。从概念上来说，semaphore 维持着一组许可证。获取锁的时候，需要先获得 semaphore 的许可才行。

一. 从 Demo 解析源码

package com.wenniuwuren.concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
* Created by zhuyb on 16/5/1.
*/
public class SemaphoreTest {

public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();

Semaphore semaphore = new Semaphore(5);

for (int i = 0; i < 10; i++) {
int count = i;
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
semaphore.acquire(); // 获取许可
System.out.println("当前循环:" + count);
System.out.println("当前还剩多少许可数量:" + semaphore.availablePermits());
Thread.sleep(10000);
semaphore.release(); // 释放占用的许可
} catch (Exception e) {
e.printStackTrace();
}

}
};
executorService.execute(runnable);
}
executorService.shutdown();
}
}

（1） 先看 Semaphore semaphore = new Semaphore(5) 的构造函数
默认使用非公平锁，调用的是继承自 AQS 的内部类 NonfairSync

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

看下 NonfairSync 的具体实现：构造函数调用父类来初始化，其实就是 AQS 的 Sync 构造函数

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);
}
}

AQS 的 Sync 构造函数：设置 AQS 的同步状态 stat

abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;

Sync(int permits) {
setState(permits);
}

// 省略无用代码
}

AQS 的状态值由具体调用的类来定义 stat 的含义，对于 Semaphore 来说 stat 的数量含义就是可以有多少个线程并发使用某个资源

protected final void setState(int newState) {
state = newState;
}

（2）semaphore.acquire(); // 获取许可

public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}

public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}

acquireSharedInterruptibly 从代码看出来是响应中断的，再看下 tryAcquireShared(arg)：AQS 中 tryAcquireShared 没有具体实现，交给具体的继承类去实现

protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}

下面是 Semaphore 的 tryAcquireShared 具体实现：可以看到用当前的 stat 值减去传入的 1。举个具体的例子，如果是第一次调用 semaphore.acquire()， 则 available 就等于初始化 Semaphore 时候的值，然后减去 acquires=1，如果小于零就要调用 doAcquireSharedInterruptibly(arg) 这个方法是在
AQS 的 FIFO 队列中排队；如果大于零则 CAS 更新 AQS 的 stat 值，说明线程获得了 Semaphore 的许可，可以成功执行

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

final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}

（3）semaphore.release(); // 释放占用的许可

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

public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}

tryReleaseShared(arg) 和 tryAcquireShared() 一样都是需要具体类自己实现的，这样才能由该类定义 stat 的具体含义：参数 releases =1 表示释放一个 Semaphore， CAS 设置新的 stat 值

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 返回 true 后进入的 doReleaseShared()：与互斥锁不同的是，共享锁在释放锁的时候会将共享锁释放信息向 AQS 的队列中传播这个共享锁已经释放的 SIGNAL，这样等待这个共享锁的线程就能较快地脱离 AQS 的等待队列。从 ws == Node.SIGNAL 分支执行的就是共享锁的向后传递 SIGNAL 方法 unparkSuccessor(h)。最外面的 for（;;）就是为了保证释放锁的正常进行，异常就是循环重试

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;
}
}

二. 总结
Semaphore 是借助 AQS(AbstractQueuedSynchronizer) 这个同步控制器来实现共享锁的获取和释放，AQS 中的同步变量 stat 在 Semaphore 的意思就是并发的数量，线程并发数量超过这个 stat 总数，之后的线程只能进入 AQS 的等待队列直到其他线程释放这个 stat，然后公平地排队获取锁或者非公平地抢占锁。