前言
简介
Semaphore 中文称信号量，它和ReentrantLock 有所区别，ReentrantLock是排他的，也就是只能允许一个线程拥有资源，Semaphore是共享的，它允许多个线程同时拥有资源，是AQS中共享模式的实现，在前面的AQS分析文章中，我也是用Semaphore去解释共享锁的
现实中，我们火爆一点儿的饭店吃饭，比如海底捞，为什么我们需要排队，是因为里面只能容纳这么多人吃饭，位置不够了，我们就要去排队，有人吃完出来了才能有新的人进去，同样的道理
使用
下面还是常规流程 可能有的人没用过，就写个小demo,介绍下他的使用
先看下代码：
/**
* @ClassName SemaphoreDemo
* @Auther burgxun
* @Description: 使用信号量的Demo
* @Date 2020/4/3 13:53
**/
public class SemaphoreDemo {
public static void PrintLog(String logContent) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm.ss.SSS");
System.out.println(String.format("%s : %s", simpleDateFormat.format(new Date()), logContent));
}
public static void main(String[] args) throws InterruptedException {
Semaphore semaphore = new Semaphore(10);
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
try {
PrintLog("Thread1 starting ......");
semaphore.acquire(5);
PrintLog("Thread1 get permits success");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
PrintLog("thread1 release permits success");
semaphore.release(5);
}
}
});
Thread thread2 = new Thread(new Runnable() {
@Override
public void run() {
try {
PrintLog("Thread2 starting ......");
semaphore.acquire(5);
PrintLog("Thread2 get permits success");
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
PrintLog("thread2 release permits success");
semaphore.release(5);
}
}
});
thread1.start();
thread2.start();
try {
semaphore.acquire(5);
PrintLog("Main thread get permits success");
Thread.sleep(3000);
} finally {
PrintLog("Main thread release permits");
semaphore.release(5);
}
}
}
上面的代码逻辑也很简答，就是设置一个信号量为10的permits，然后代码中新开2个线程，也获取semaphore的5个permits，同时主线程也获取5个permits
让我们看下结果：
2020-04-08 11:53.40.539 : Thread1 starting ......
2020-04-08 11:53.40.539 : Main thread get permits success
2020-04-08 11:53.40.539 : Thread2 starting ......
2020-04-08 11:53.40.544 : Thread1 get permits success
2020-04-08 11:53.43.543 : Main thread release permits
2020-04-08 11:53.43.543 : Thread2 get permits success
2020-04-08 11:53.43.544 : thread1 release permits success
2020-04-08 11:53.46.543 : thread2 release permits success
从结果上可以看到 程序启动的时候，Thread1 和Thread2 还有主线程同时要获取permits,但是由于Semaphore的permits一共就是10个，所以当主线程和Thread1获取到了以后，Thread2 虽然启动了 但是会阻塞在这边，进入AQS的SyncQueue中，当MainThread或者Thread1 执行完成，释放permits后，Thread2 才会从阻塞队列中 唤醒回来从新获取的信号量，后面继续执行！
源码分析
看完了 上面的小Demo 相信你对信号量有了一定的了解，那我们就进入源码中看下，是怎么实现的，首先我们先看下Semaphore的结构图：
类结构图
从图上我们可以看到 这个类机构和我们之前看的ReentrantLock差不多，有一个Sync静态的抽象类，然后还有2个继承Sync的类，一个是公平类FairSync ，另外一个是非公平的NonfairSync
关于公平和非公平的选择 我在ReentrantLock的结尾部分已经做了部分阐述，这边就不说了
那么就看下代码实现吧！
Sync
abstract static class Sync extends AbstractQueuedSynchronizer {
/**
* m默认的构造函数 设置AQS同步器的State值
*/
Sync(int permits) {
setState(permits);
}
/**
* 获取同步器的状态值 State 这个就是获取设置的许可数量
*/
final int getPermits() {
return getState();
}
/**
* 实现共享模式下非公平方法的获取资源
*/
final int nonfairTryAcquireShared(int acquires) {
for (; ; ) {//自旋
int available = getState();//当前的同步器的状态值
int remaining = available - acquires;//本次用完 还剩下几个permits值
// 如果剩余小于0或者CAS 成功 就返回 后面利用这个方法的时候 会判断返回值的
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
/**
* 共享模式下的尝试释放资源
*/
protected final boolean tryReleaseShared(int releases) {
for (; ; ) {
int current = getState();
int next = current + releases;//用完的permits 就要加回去
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))//CAS 修改AQS的State 由于可能存在多个线程同时操作的State
// 所以要使用CAS操作 失败了就继续循环，CAS成功就返回
return true;
}
}
/**
* 根据参数reductions 去减少信号量
*/
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;
}
}
}
Sync 里面的方法不多，都是常见的讨论，里面默认提供一个非公平版本的获取Permits，还有统一的释放Permits的方法，其余的就是一个获取信号量方法getPermits，和减少当前Permits数量的方法reducePermits，最后还有一个清空信号量的方法drainPermits，drainPermits这个方法好多文章里面 都翻译了因为注解，都翻译为获取并返回许可，但是这个方法其实主要做的还是清空Semaphore里面的信号量的操作,有人会想 为什么提供这个一个鸡肋方法么，因为先用getPermits获取 然后使用reducePermits减少不就好了么，哈哈，这边要考虑到多线程并发的情况，这边只能使用CAS的操作去更新！每一行代码都有它存在的意义，就像人一样，存在即合理！
NonfairSync
/**
* 非公平版本
*/
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);
}
}
这个类 真没啥好说的，都是调的Sync里面的实现
FairSync
/**
* 公平版本
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;
FairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
for (; ; ) {//这边为什么要用自旋 主要是因为当前版本是共享模式 可能会多个线程同事操作State 导致当前的CAS 操作失败 所以要做重试
if (hasQueuedPredecessors())//如果当前的SyncQueue中还有等待线程 那就直接返回-1 不让当前线程获取资源
return -1;
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
这个公平方法的初始化方法和非公平的一样，区别就是这个tryAcquireShared方法的实现，一个是自己实现的，一个是调的Sync的实现，这个2个方法 虽然区别也不大，但是执行的逻辑却是不一样的，主要是这个hasQueuedPredecessors方法，这个方法就是获取AQS的SyncQueue中 是否还有等待获取资源的线程，这就是公平和非公平的区别，上一篇ReentrantLock中我也做个说明，就相当于插队一样，如果公平的话 大家获取不到的时候 就到后面排队等待，大家挨个来，但是非公共的获取 就是一上来，我不管后面有没有等待的人，如果有满足我获取的条件，我就直接占用！
Semaphore 构造函数
Semaphore有个构造函数
- Semaphore(int permits) 这个是默认的构造函数，是非公平permits就是信号量许可的总数
- Semaphore(int permits, boolean fair) 这个和上面的区别就是 可以设置实现的版本 true就是FairSync false 就是NonfairSync
Semaphore 成员方法
获取
| 方法 | 是否响应中断 | 是否阻塞 |
|---|---|---|
| acquire() | 是 | 是 |
| acquire(int permits) | 是 | 是 |
| acquireUninterruptibly() | 否 | 是 |
| acquireUninterruptibly(int permits) | 否 | 是 |
| tryAcquire() | 否 | 否 |
| tryAcquire(int permits) | 否 | 否 |
| tryAcquire(long timeout, TimeUnit unit) | 是 | 是(时间可控） |
| tryAcquire(int permits, long timeout, TimeUnit unit) | 是 | 是(时间可控） |
上面的方法 是我对Semaphore获取permits的使用总结，记不住也没事儿，看看名字或者到时候看下注解，应该也能看明白的~
调一个核心方法acquire吧
/**
* Semaphore中
* 获取资源
*/
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
/**
* AbstractQueuedSynchronizer 中
* 共享模式下的 获取资源 可以响应中断
*/
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())//检测下 中断标识符 如果发生了中断 就抛出中断异常
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)//尝试获取资源 如果返回值小于0 说明当前的同步器里面的值 不够当前获取 就进入排队
doAcquireSharedInterruptibly(arg);
}
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//以共享模式加入到阻塞队列中 这里addWaiter和独占锁加锁使用的是同一个方法 不清楚的 可以看之前的文章
final Node node = addWaiter(Node.SHARED);// 返回成功加入队尾的节点
boolean failed = true;//标识是否获取资源失败
try {
for (; ; ) {//自旋
final Node p = node.predecessor();// 获取当前节点的前置节点
if (p == head) {// 如果前置节点是head 那就去尝试获取资源，因为可能head已经释放了资源
int r = tryAcquireShared(arg);
if (r >= 0) {// 如果获取成功且大于等于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);
}
}
/**
* 更新prev节点状态 ，并根据prev节点状态判断是否自己当前线程需要阻塞
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;// node的prev节点的状态
if (ws == Node.SIGNAL) // 如果SIGNAL 就返回true 就会执行到parkAndCheckInterrupt方法里面
return true;
/*
* 如果ws 大于0 这里是只能为1，如果是1说明线程已经取消，相当于无效节点
* 者说明 当前node 节点加入到了一个无效节点后面，那这个必须处理一下
node.prev = pred = pred.prev
* 这个操作 我们拆解下来看，下看 pred = pred.prev这个的意思是把prev节点的prev*节点 赋值给prev节点
*后面再看 node.prev = pred 联合 刚才的赋值 这个的意思就是把prev节点的prev节点和node关联起来，
*原因我上面也说了因为pre节点线程取消了,所以node节点不能指向pre节点 只能一个一个的往前找，
*找到waitStatus 小于或者等于0的结束循环最后再把找到的pre节点执行node节点 ,这样就跳过了所有无效的节点
*/
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
*这边的操作就是把pred 节点的状态设置为SIGNAL，这样返回false 这样可以返回到上面的自旋中
*再次执行一次，如果还是获取不到锁，那么又回到当前的shouldParkAfterFailedAcquire方法 执行到方法最上面的判断
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
/**
* 阻塞当前线程，并在恢复后坚持是否发送了中断
* @return {@code true} if interrupted
*/
private final boolean parkAndCheckInterrupt() {
/*
* 这边线程阻塞，只有2中方式唤醒当前线程，
* 一种方式就是 当前线程发生中断
* 另外一个情况就是 资源释放的时候会调unpark 方法 唤醒当前的线程 这个会在下一篇会讲到
*/
LockSupport.park(this);
return Thread.interrupted();//检查线程在阻塞过程中 是否发生了中断
}
这其中 tryAcquireShared 方法 都是子类去重写实现的，非公平版本和公平版本的实现 上文已经描述过！
这其中的整个实现都是在AQS中的，在前面的AQS文章中也详细的描述过~不清楚的 去前面的文章中看下
下面是整个方法的调用关系图如下：
释放
/**
* 释放资源
*/
public void release() {
sync.releaseShared(1);
}
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
释放方法调用了Sync的releaseShared 实际上就是调用了AQS内部的方法releaseShared
/**
* AbstractQueuedSynchronizer 中
* 共享版本的 释放资源
*/
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {//tryReleaseShared 还是和之前的套路一样 子类去重写的
doReleaseShared();//是不是很熟悉
return true;
}
return false;
}
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
/**
* 共享模式下的释放资源
*/
private void doReleaseShared() {
for (; ; ) {
Node h = head;
if (h != null && h != tail) {// 这个head!=tail 说明阻塞队列中至少2个节点 不然也没必要去传播唤醒 如果就自己一个节点 就算资源条件满足 还换个谁呢？
int ws = h.waitStatus;// head 节点状态SIGNAL
if (ws == Node.SIGNAL) {// 如果head状态是
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);//是和独占锁释放用的同样的方法 唤醒的是下一个节点 前面的文章有分析到
} else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; //这边设置为-3 是为了唤醒的传播 也就是满足上一个方法有判断waitStatus 小于0
}
if (h == head)
break;
}
}
/**
* 唤醒等待线程去获取资源
*/
private void unparkSuccessor(Node node) {
/*
* 这边判断了下如果当前节点状态小于0，更新这边的节点状态的0，是为了防止多次释放的时候 会多次唤醒，
* 因为上面的方法有个判断waitStatus不等0才会执行到这个方法里面
*/
int ws = node.waitStatus;//这边的弄得节点就是 要释放的节点 也就是当前队列的头节点
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
// 如果当前节点的next 节点 不存在或者waitStatus 大于0 说明next节点的线程已取消
if (s == null || s.waitStatus > 0) {
s = null;
//这个循环就是 从尾部节点开始往前找，找到离node节点也就是当前释放节点最近的一个非取消的节点
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
/*
*一开始觉得 这行判断null有点多余 因为上面去for 循环去找s 的时候 已经判断了不等于null
*才可以进下面的循环赋值的 后来一想 不对，你们猜为什么?
*因为 可能在循环的过程中t在赋值给s后，继续循环 虽然条件不满足，
*但是这个时候已经比修改成null 了 我是这么想的哈~不知道对不对~
*/
if (s != null)
LockSupport.unpark(s.thread);// 这边就是唤醒当前线程去获取资源，
}
具体里面的doReleaseShared方法 我之前在AQS的共享锁的文章里面 都详细做了概述，这边我就不再次赘述了！
tryReleaseShared 方法 还是和之前的套路一样，AQS里面没有实现 只是写了个抛出异常的方法，tryReleaseShared方法需要子类去重写实现，具体为什么不写成抽象方法，哈哈 这个问题 自己去AQS中的文章去找下吧~相信你能找到答案
总结
看完了整个代码的实现，Semphore实际上就是一个共享锁，多个线程可以共享一个AQS中的State,Semphore常见使用场景是限制资源的并发访问的线程数量