Semaphore的结构
public class Semaphore implements java.io.Serializable {
private static final long serialVersionUID = -3222578661600680210L;
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {
// ......
}
/**
* NonFair version
*/
static final class NonfairSync extends Sync {
// ......
}
/**
* Fair version
*/
static final class FairSync extends Sync {
// ......
}
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public boolean tryAcquire() {
return sync.nonfairTryAcquireShared(1) >= 0;
}
public void release() {
sync.releaseShared(1);
}
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
public boolean tryAcquire(int permits) {
if (permits < 0) throw new IllegalArgumentException();
return sync.nonfairTryAcquireShared(permits) >= 0;
}
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
/**
* 返回可用的许可
*/
public int availablePermits() {
return sync.getPermits();
}
/**
* 耗尽许可
*/
public int drainPermits() {
return sync.drainPermits();
}
/**
* 减少许可
*/
protected void reducePermits(int reduction) {
if (reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}
// 其他省略
}
可以看到Semaphore中定义了一个抽象同步器（Sync）、非公平同步器（NonfairSync）和公平同步器（FairSync），同时非公平同步器和公平同步器都继承抽象同步器。
同时Semaphore中存在一个全局的抽象同步器属性，然后通过构造方法来进行初始化，通过fair参数来指定到底是使用非公平的还是公平的同步器（默认非公平），通过permits参数来指定同步资源的个数。
同时Semaphore的acquire()方法将会直接调用AQS的acquireSharedInterruptibly()方法，tryAcquire()方法调用抽象同步器的nonfairTryAcquireShared()方法，release()方法直接调用AQS的releaseShared()方法。
剖析抽象同步器
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 (;;) {
// 当前同步资源的个数 - 要获取的同步资源个数，如果大于等于0则表示获取同步资源成功，则通过CAS更新同步状态的值，然后返回剩余的可用资源个数，否则表示获取同步资源失败，返回负数
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
/**
* 尝试释放同步资源
*/
protected final boolean tryReleaseShared(int releases) {
// 死循环保证操作最终肯定成功
for (;;) {
// 当前同步资源的个数 + 要释放的同步资源个数 ，然后通过CAS更新同步状态的值
int current = getState();
int next = current + releases;
if (next < current) // 如果release是负数则抛出异常
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
/**
* 减少许可
*/
final void reducePermits(int reductions) {
// 死循环保证操作最终肯定成功
for (;;) {
// 当前同步资源的个数 - 要减少的同步资源个数，然后通过CAS更新同步状态的值
int current = getState();
int next = current - reductions;
if (next > current) // 如果reductions是负数，则抛出异常
throw new Error("Permit count underflow");
if (compareAndSetState(current, next))
return;
}
}
/**
* 耗尽许可
*/
final int drainPermits() {
// 死循环保证操作最终肯定成功
for (;;) {
// 通过CAS将同步状态的值设置为0
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
}
可以看到抽象同步器的构建方法会初始化同步资源的个数，同时提供了nonfairTryAcquireShared()、tryReleaseShared()、reducePermits()、drainPermits()方法。
同时抽象同步器已经重写了AQS的tryReleaseShared()方法，因此抽象同步器的子类还需要重写AQS的tryAcquireShared()方法。
剖析非公平同步器
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -2694183684443567898L;
/**
* 显式调用父类的带permits参数的构建方法
*/
NonfairSync(int permits) {
super(permits);
}
/**
* 尝试获取同步资源
*/
protected int tryAcquireShared(int acquires) {
// 直接调用抽象同步器的nonfairTryAcquireShared()方法
return nonfairTryAcquireShared(acquires);
}
}
可以看到非公平同步器的构造方法会显式调用父类的带permits参数的构建方法，用于初始化同步资源。
同时非公平同步器的tryAcquireShared()方法将会直接调用抽象同步器的nonfairTryAcquireShared()方法。
剖析公平同步器
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;
/**
* 显式调用父类的带permits参数的构建方法
*/
FairSync(int permits) {
super(permits);
}
/**
* 尝试获取同步资源
*/
protected int tryAcquireShared(int acquires) {
// 死循环保证操作最终肯定成功
for (;;) {
// 只有当当前线程就是等待队列中头节点的后继节点所封装的线程，或者当前等待队列为空或只有一个节点，才允许尝试获取同步资源，否则表示获取同步资源失败，返回负数
if (hasQueuedPredecessors())
return -1;
// 当前同步资源的个数 - 要获取的同步资源个数，如果大于等于0则表示获取同步资源成功，则通过CAS更新同步状态的值，然后返回剩余的可用资源个数，否则表示获取同步资源失败，返回负数
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
深圳网站建设www.sz886.com
