Semaphore源码分析
前面我们分析了ReentrantLock，通过查看Semaphore的源码发现其与ReentrantLock非常类似，接下来我们就详细的分析下Semaphore。
Semaphore当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。 Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能，但实现上要复杂些。
1. 属性
private final Sync sync;Sync是一个继承了AbstractQueuedSynchronizer的内部虚拟类。其源码如下（暂时不过多解析）：
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;
}
}
}2. 构造函数
通过源码查看Semaphore有两个构造函数，源码如：
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}第一个构造函数式直接构造了一个NonfairSync实现的，第二个构造函数根据fair的值来构造FairSync或NonfairSync，FairSync和NonfairSync是Sync的两个实现，因此Semaphore信号量和ReentrantLock锁一样，也存在公平和不公平。
如果Semaphore委托给FairSync类实现，就是公平信号量。
如果Semaphore委托给NonFairSync类实现，就是非公平信号量。
非公平Semaphore信号量对于任何申请许可的线程来说，都是第一时间看是否有多余的许可，如果有则给此线程，如果没有则进队列排队等待，而不是此线程直接进AQS队列排队等待按顺序来拿到许可，利用此间隙来分配许可可以提高并发量。但是会引发一个问题：越活跃的线程越能够拿到许可，造成“饥渴死”现象。
3. 常用方法
3.1 void acquire()
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。这个方法直接调用的是AQS的acquireSharedInterruptibly(int arg)方法。我们详细看下acquireSharedInterruptibly方法：
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}此函数做了如下几件事：
（1）检测此线程是否被中断了，如果中断，则抛中断异常。如果没有被中断，则进行2
（2）调用tryAcquireShares(int arg)方法以共享模式来获取对象(锁)，如果此方法值大于等于0则表明获取到锁立即返回，否则进行 3
（3）由于没有获取到锁,则调用doAcquireSharedInterruptibly方法进入AQS同步队列进行自旋等待。
下面就先看下tryAcquireShares(int arg)方法是怎么样的。由于存在非公平和公平Semaphore，因此这里有一点点不同，也只有这里不同。
在FairSync中的tryAcqureShares方法源码如下：
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;
}
}在NonfairSync中的源码如下：
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;
}
}比较非公平的公平的源码可以看到，公平Semaphore对象对许可的分配是按照FIFO队列来分配的，以保证公平性。因此其首先调用了hasQueuedPredecessors方法来判断当前线程是否是AQS队列中的头结点，如果不是，则不给于分配需要加入到同步队列中等待。而非公平的Semaphore对象就不是这样的，有许可我们就分配出去，不需要排队等待。
当一个线程第一次获取共享锁失败之后，就会调用doAcquireSharedInterruptibly(int
arg)方法来自旋等待获取锁，跟踪代码：
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
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
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}此方法的思路如下：
（1）首先调用addWaiter方法将当前线程构成的节点加入到同步队列AQS中
（2）将一直自旋检测该线程节点的前驱节点是否为头结点，如果是则调用tryAcquireShared尝试的获取锁。如果不是，则进行 3
（3）判断此节点是否需要阻塞以及异常检测。
acquire方法总结如下：
（1）尝试在非公平模式下获取一个许可,或者叫做锁。如果获取到则立即返回并将许可计数器减一，如果没有获取到，则进行2
（2）进入到AQS队列自旋等待，当此节点的前驱是头结点后，又开始尝试获取锁。直至成功获取或中断取消。
3.2 void release()
public void release() {
sync.releaseShared(1);
}也是直接使用了AQS的relaseShared方法来释放一个锁，具体看下AQS的relaseShared方法：
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}此方法的功能：
（1）调用tryReleaseShared方法来完成AQS状态位的设置。如果设置成功，则进行2
（2）调用doReleaseShared()来唤醒在AQS中等待的需要许可的后继节点来获取许可。
继续跟踪下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;
}
}这个方法功能比较简单，就是用来设置状态的。
然后分析下doReleaseShared方法：
private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
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;
}
}此方法以共享模式释放，发信号给后继的一些节点，对于独占模式，只会调用unparkSuccessor来唤醒AQS队列总的头结点(如果其需要信号)
3.3 acquire(int permits) 和release(int permits)
上面介绍的是在无参数情况下获取和释放锁，实际上acquire(int permits) 和release(int permits)这两个方法只是根据传入的值来获取和释放相应数量的锁，就不过多介绍了，源码如下：
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
扫一扫
4680
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
