Semaphore实现原理
Semaphore的acquire 方法
首先定义一个变量,初始化 semaphore 设置凭证为 0 个
public static Semaphore semaphore = new Semaphore(0);
这个方法尝试去获取一个信号量
semaphore.acquire();
我们看源码实现,可以看到这个方法调用了 sync 的 acquireSharedInterruptibly 方法
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
这个sync是一个Semaphore的内部类,是 默认是 NonfairSync, 而NonfairSync 继承了 Sync
而Sync 又是大名鼎鼎的 AbstractQueuedSynchronizer 的子类
那么 NonfairSync 的 acquireSharedInterruptibly 执行了什么操作呢 ?
由于 acquireSharedInterruptibly 父类 AbstractQueuedSynchronizer 的一个 final 标记的方法
无法被子类复写
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
首先判断当前线程是否是已中断的状态,如果是直接抛出中断异常,
if (Thread.interrupted())
throw new InterruptedException();
然后调用 tryAcquireShared 的方法 tryAcquireShared 由子类 Sync 实现 参考 1.2
if (tryAcquireShared(arg) < 0)
如果凭证已经用完,则调用 doAcquireSharedInterruptibly 方法 参考1.3
doAcquireSharedInterruptibly(arg);
}
####### 1.2
这里可以看到 使用自选的方式 把 available(当前可用凭证) - acquires(要获取的凭证,默认 = 1)
如果剩余数量小于0 说明凭证已经用完 直接返回
如果使用cas操作替换成功,说明 available - acquires 的操作执行成功,意思是说
成功的得到了一个凭证
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
####### 1.3 此方法由 AQS 框架实现
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
创建一个node节点添加到队列尾部 addWaiter 方法 并返回添加成功的node节点
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) {
设置当前节点为头节点 唤醒p节点
setHeadAndPropagate(node, r);
p.next = null;
failed = false;
return;
}
}
如果不是头节点,shouldParkAfterFailedAcquire 方法则会给这个节点 设置一个
Node.SIGNAL 的标记,我们不去理会具体的代码实现,只需要知道这个方法做了一件事,
把当前线程设置一个暂停标记,第一次执行返回false,因为是一个自旋的操作,当前线程会
再次执行一次上面的逻辑,第二次执行返回true 调用
parkAndCheckInterrupt 这个方法 见名知意,就是调用
LockSupport.park(this) 阻塞当前线程,并且 返回当前线程的状态,如果是被中断
直接抛出中断异常,反之 这个操作已经把当前线程阻塞了
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
semaphore的release()方法详解
方法调用由Sync对象直接调用父类 AQS 的 final 方法实现的
semaphore.release();
这是AQS里的代码实现
public final boolean releaseShared(int arg) {
tryReleaseShared 方法 aqs 并没有实现 二是由子类 Sync实现 参考 1.2
此处只有返回true或者抛出异常的可能
返回 true 说明释放了一个令牌,其他的线程可以继续获取令牌了
但是线程都在阻塞队列里阻塞,如何唤醒他们呢?
doReleaseShared()会告诉我门答案 参见 1.3
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
### 1.2
protected final boolean tryReleaseShared(int releases) {
这里有一个自旋的操作
for (;;) {
得到当前凭证数量
int current = getState();
当前凭证数量 + releases(releases 此时 = 1)
int next = current + releases;
如果返回一个返还一个 -1 应该会有此异常吧
if (next < current)
throw new Error("Maximum permit count exceeded");
然后 cas 操作设置当前凭证数量为 next,
自选操作,直到设置成功或者 异常退出
if (compareAndSetState(current, next))
return true;
}
}
#### 1.3
private void doReleaseShared() {
这里也是一个自旋的操作
for (;;) {
Node h = head;
得到当前头节点,如果不为空而且不是队尾
if (h != null && h != tail) {
得到节点的等待状态
int ws = h.waitStatus;
如果等于阻塞时设置的 Node.SIGNAL cas 替换状态,并且唤醒 头节点的线程
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue;
此时头节点已经唤醒,线程继续执行代码
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
if (h == head)
break;
}
}