1. 简介
前面我们针对CountDownLatch和CyclicBarrier进行了学习，CountDownLatch用于帮助我们实现“倒计时”的功能，当count=0的时候则触发await的线程进行执行。而CyclicBarrier则适用于到达某一状态后接着执行下一步操作的情况。本次介绍的Semaphore是一个计信号数量。
Semaphore通过acquire()方法申请信号量，如果当前无信号量可用，则线程处于阻塞状态，如果有可用信号量，线程正常进行。release方法用于释放一个“锁定占用”的信号量。
Semaphore 通常用于限制访问某些资源（物理或逻辑的）的线程数目。
下面看一个jdk中带的例子，该例子中展示了使用Semaphone控制数据的访问。
class Pool {
private static final int MAX_AVAILABLE = 100;
private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
public Object getItem() throws InterruptedException {
available.acquire();
return getNextAvailableItem();
}
public void putItem(Object x) {
if (markAsUnused(x))
available.release();
}
// Not a particularly efficient data structure; just for demo
protected Object[] items = ... whatever kinds of items being managed
protected boolean[] used = new boolean[MAX_AVAILABLE];
protected synchronized Object getNextAvailableItem() {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (!used[i]) {
used[i] = true;
return items[i];
}
}
return null; // not reached
}
protected synchronized boolean markAsUnused(Object item) {
for (int i = 0; i < MAX_AVAILABLE; ++i) {
if (item == items[i]) {
if (used[i]) {
used[i] = false;
return true;
} else
return false;
}
}
return false;
}
}
2、Api分析
Semaphore提供了两个关键的方法acquire()和release()方法。分别用于申请信号量和释放信号量。
如下面示例代码所示：
public class FirstDemo {
static Semaphore semaphore = new Semaphore(2);
/**
* @param args
*/
public static void main(String[] args) {
for(int i=0;i<4;i++){
new Thread(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " ready");
try {
semaphore.acquire();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " go");
semaphore.release();
}
}.start();
}
}
}
执行结果：
Thread-0 ready
Thread-0 go
Thread-2 ready
Thread-2 go
Thread-1 ready
Thread-3 ready
Thread-1 go
Thread-3 go
从执行结果来看，最多只能连续执行go两次，间接的印证最多同时只有两个信号量在工作。补充一个特殊情况，当信号量Semaphore = 1 时，它可以当作互斥锁使用。其中0、1就相当于它的状态，当=1时表示其他线程可以获取，当=0时，排他，即其他线程必须要等待。
3. 源码解析
在源码中，Semaphore同样包含一个继承AQS的子类Sync。
public class Semaphore implements java.io.Serializable {
private static final long serialVersionUID = -3222578661600680210L;
/** All mechanics via AbstractQueuedSynchronizer subclass */
private final Sync sync;
/**
* Synchronization implementation for semaphore. Uses AQS state
* to represent permits. Subclassed into fair and nonfair
* versions.
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;
Sync(int permits) {
setState(permits);
}
final int getPermits() {
return getState();
}
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
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;
}
}
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;
}
}
final int drainPermits() {
for (;;) {
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
}
....
}
通过使用AQS类的state值来存储信号量，原理类似于CountDownLatch，都是通过AQS的state值进行计数。
创建一个Semaphore对象可以通过构造方法：
/**指定信号量个数*/
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
/**
* Creates a {@code Semaphore} with the given number of
* permits and the given fairness setting.
*
* @param permits the initial number of permits available.
* This value may be negative, in which case releases
* must occur before any acquires will be granted.
* @param fair {@code true} if this semaphore will guarantee
* first-in first-out granting of permits under contention,
* else {@code false}
*/
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
通过上面的构造函数，可以看到默认情况下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);
}
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);
}
}
在acquire方法中，调用sync的acquireSharedInterruptibly(1)方法，如果线程被iterrupted则抛出 InterruptedException异常。通过tryAcquireShared(arg) 获取状态值，最关键的代码是：
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
获取当前的state值，如果可用state值-1后小于0，即当前信号量被占满，则返回一个负数，然后执行doAcquireSharedInterruptibly()方法添加到等待队列。
4. 总结
无论ReentrantLock或CyclicBarrier内部都是基于AQS进行实现，实现的原理有所差异而已。
