深入理解Semaphore
使用
Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。
Semaphore经常用于限制获取某种资源的线程数量。下面举个例子，比如说操场上有5个跑道，一个跑道一次只能有一个学生在上面跑步，一旦所有跑道在使用，那么后面的学生就需要等待，直到有一个学生不跑了，下面是这个例子：
/**
* 操场，有5个跑道
* Created by Xingfeng on 2016-12-09.
*/
public class Playground {
/**
* 跑道类
*/
static class Track {
private int num;
public Track(int num) {
this.num = num;
}
@Override
public String toString() {
return "Track{" +
"num=" + num +
'}';
}
}
private Track[] tracks = {
new Track(1), new Track(2), new Track(3), new Track(4), new Track(5)};
private volatile boolean[] used = new boolean[5];
private Semaphore semaphore = new Semaphore(5, true);
/**
* 获取一个跑道
*/
public Track getTrack() throws InterruptedException {
semaphore.acquire(1);
return getNextAvailableTrack();
}
/**
* 返回一个跑道
*
* @param track
*/
public void releaseTrack(Track track) {
if (makeAsUsed(track))
semaphore.release(1);
}
/**
* 遍历，找到一个没人用的跑道
*
* @return
*/
private Track getNextAvailableTrack() {
for (int i = 0; i < used.length; i++) {
if (!used[i]) {
used[i] = true;
return tracks[i];
}
}
return null;
}
/**
* 返回一个跑道
*
* @param track
*/
private boolean makeAsUsed(Track track) {
for (int i = 0; i < used.length; i++) {
if (tracks[i] == track) {
if (used[i]) {
used[i] = false;
return true;
} else {
return false;
}
}
}
return false;
}
}
从上面可以看到，创建了5个跑道对象，并使用一个boolean类型的数组记录每个跑道是否被使用了，初始化了5个许可证的Semaphore，在获取跑道时首先调用acquire(1)获取一个许可证，在归还一个跑道是调用release(1)释放一个许可证。接下来再看启动程序，如下：
public class SemaphoreDemo {
static class Student implements Runnable {
private int num;
private Playground playground;
public Student(int num, Playground playground) {
this.num = num;
this.playground = playground;
}
@Override
public void run() {
try {
//获取跑道
Playground.Track track = playground.getTrack();
if (track != null) {
System.out.println("学生" + num + "在" + track.toString() + "上跑步");
TimeUnit.SECONDS.sleep(2);
System.out.println("学生" + num + "释放" + track.toString());
//释放跑道
playground.releaseTrack(track);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Executor executor = Executors.newCachedThreadPool();
Playground playground = new Playground();
for (int i = 0; i < 100; i++) {
executor.execute(new Student(i+1,playground));
}
}
}
上面的代码中，Student类代表学生，首先获取跑道，一旦获取到就打印一句话，然后睡眠2s，然后再打印释放，最后归还跑道。
源码解析
Semaphore有两种模式，公平模式和非公平模式。公平模式就是调用acquire的顺序就是获取许可证的顺序，遵循FIFO；而非公平模式是抢占式的，也就是有可能一个新的获取线程恰好在一个许可证释放时得到了这个许可证，而前面还有等待的线程。
构造方法
Semaphore有两个构造方法，如下：
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
从上面可以看到两个构造方法，都必须提供许可的数量，第二个构造方法可以指定是公平模式还是非公平模式，默认非公平模式。
Semaphore内部基于AQS的共享模式，所以实现都委托给了Sync类。
这里就看一下NonfairSync的构造方法：
NonfairSync(int permits) {
super(permits);
}
可以看到直接调用了父类的构造方法，Sync的构造方法如下：
Sync(int permits) {
setState(permits);
}
可以看到调用了setState方法，也就是说AQS中的资源就是许可证的数量。
获取许可
先从获取一个许可看起，并且先看非公平模式下的实现。首先看acquire方法，acquire方法有几个重载，但主要是下面这个方法
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
从上面可以看到，调用了Sync的acquireSharedInterruptibly方法，该方法在父类AQS中，如下：
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//如果线程被中断了，抛出异常
if (Thread.interrupted())
throw new InterruptedException();
//获取许可失败，将线程加入到等待队列中
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
AQS子类如果要使用共享模式的话，需要实现tryAcquireShared方法，下面看NonfairSync的该方法实现：
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
该方法调用了父类中的nonfairTyAcquireShared方法，如下：
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
//获取剩余许可数量
int available = getState();
//计算给完这次许可数量后的个数
int remaining = available - acquires;
//如果许可不够或者可以将许可数量重置的话，返回
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
从上面可以看到，只有在许可不够时返回值才会小于0，其余返回的都是剩余许可数量，这也就解释了，一旦许可不够，后面的线程将会阻塞。看完了非公平的获取，再看下公平的获取，代码如下：
protected int tryAcquireShared(int acquires) {
for (;;) {
//如果前面有线程再等待，直接返回-1
if (hasQueuedPredecessors())
return -1;
//后面与非公平一样
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
从上面可以看到，FairSync与NonFairSync的区别就在于会首先判断当前队列中有没有线程在等待，如果有，就老老实实进入到等待队列；而不像NonfairSync一样首先试一把，说不定就恰好获得了一个许可，这样就可以插队了。
看完了获取许可后，再看一下释放许可。
释放许可
释放许可也有几个重载方法，但都会调用下面这个带参数的方法，
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
releaseShared方法在AQS中，如下：
public final boolean releaseShared(int arg) {
//如果改变许可数量成功
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
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");
//CAS改变许可数量成功，返回true
if (compareAndSetState(current, next))
return true;
}
}
从上面可以看到，一旦CAS改变许可数量成功，那么就会调用doReleaseShared()方法释放阻塞的线程。
减小许可数量
Semaphore还有减小许可数量的方法，该方法可以用于用于当资源用完不能再用时，这时就可以减小许可证。代码如下：
protected void reducePermits(int reduction) {
if (reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}
可以看到，委托给了Sync，Sync的reducePermits方法如下：
final void reducePermits(int reductions) {
for (;;) {
//得到当前剩余许可数量
int current = getState();
//得到减完之后的许可数量
int next = current - reductions;
if (next > current) // underflow
throw new Error("Permit count underflow");
//如果CAS改变成功
if (compareAndSetState(current, next))
return;
}
}
从上面可以看到，就是CAS改变AQS中的state变量，因为该变量代表许可证的数量。
获取剩余许可数量
Semaphore还可以一次将剩余的许可数量全部取走，该方法是drain方法，如下：
public int drainPermits() {
return sync.drainPermits();
}
Sync的实现如下：
final int drainPermits() {
for (;;) {
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
可以看到，就是CAS将许可数量置为0。
总结
Semaphore是信号量，用于管理一组资源。其内部是基于AQS的共享模式，AQS的状态表示许可证的数量，在许可证数量不够时，线程将会被挂起；而一旦有一个线程释放一个资源，那么就有可能重新唤醒等待队列中的线程继续执行。
深入理解Semaphore相关推荐
- 聊聊高并发（二十五）解析java.util.concurrent各个组件（七） 理解Semaphore
前几篇分析了一下AQS的原理和实现,这篇拿Semaphore信号量做例子看看AQS实际是如何使用的. Semaphore表示了一种可以同时有多个线程进入临界区的同步器,它维护了一个状态表示可用的票据, ...
- 理解Semaphore及其用法详解
Mutex是一把钥匙,一个人拿了就可进入一个房间,出来的时候把钥匙交给队列的第一个.一般的用法是用于串行化对critical section代码的访问,保证这段代码不会被并行的运行. Semaphor ...
- 并发工具类（三）控制并发线程数的Semaphore
http://ifeve.com/concurrency-semaphore/ 简介 Semaphore(信号量)是用来控制同时访问特定资源的线程数量,它通过协调各个线程,以保证合理的使用公共资源.很 ...
- java多线程的同步控制_Java多线程并发控制工具信号量Semaphore，实现原理及案例...
信号量(Semaphore)是Java多线程兵法中的一种JDK内置同步器,通过它可以实现多线程对公共资源的并发访问控制.一个线程在进入公共资源时需要先获取一个许可,如果获取不到许可则要等待其它线程释放 ...
- 瞅一瞅JUC提供的限流工具Semaphore
微服务架构发展到今天,各个服务之前的调用.接口请求越来越频繁,服务器承受的压力自然也越来越大.如果放任所有请求请求到服务器,不管是服务器也好还是数据库也好,都可能被因为无法承受大批量的请求而阻塞.宕机 ...
- Semaphore详解
Semaphore基本使用场景 Semaphore的基本使用场景是限制一定数量的线程能够去执行. 举个简单的例子: 一个单向隧道能同时容纳10个小汽车或5个卡车通过(1个卡车等效与2个小汽车), 而隧 ...
- 2022金三银四面试总结-Java高级篇
Java面试总结 1.你用过哪些集合类? 大公司最喜欢问的Java集合类面试题 40个Java集合面试问题和答案 java.util.Collections 是一个包装类.它包含有各种有关集合操作的静 ...
- Java 常用限流算法解析
前言 限流作为高并发场景下抵挡流量洪峰,保护后端服务不被冲垮的一种有效手段,比如大家熟知的限流组件guawa,springcloud中的Hystrix,以及springcloud-alibaba生态中 ...
- JUC快速入门各个知识点汇总
文章目录 前言 各类锁汇总 相关锁知识点 可重入锁与不可重入锁 乐观锁与悲观锁 自旋锁(含自定义自旋锁) 知识补充 上下文切换 CPU多层缓存架构 介绍CPU的三级缓存 缓存一致性协议 导致的问题 一 ...
最新文章
- 远程控制virtual box虚拟机系统的三种方式
- 2020牛客多校第3场：[Points Construction Problem + 思维题+构造]
- SAP WM 2-Step Picking的TO单据特殊的地方
- Ubuntu 创建文件快捷方式 启动器
- 《Linux总线、设备与驱动》USB设备发现机制
- arcgis python编程案例-面向ArcGIS的Python脚本编程
- Sasha and Sticks
- presentViewController 动画处理
- linux：Too Many Open Files（打开的文件过多）
- quot c语言数组压缩 quot,程序员之---C语言细节12（指针和数组细节，quot;//quot;的可移植性说明）...
- oracle近三个月内,在oracle中的前三个月SQL
- jquery ajax 跨域_Laravel 的跨域问题解决方案
- Ubuntu18.04安装Gstreamer1.0(六)
- 在苹果Mac中巧用聚焦搜索Spotlight
- 【牛客练习赛57：D】回文串（回文树求前/后缀最长回文子串）
- 融易宝项目之EasyExcel和数据字典的使用
- pyc文件反编译成py文件
- 360浏览器网页无法连接服务器,360浏览器打不开网页的解决方法教程
- 「Injective衍生品市场创意大赛」角逐“最强王者”，就等你来
- 梧桐冷 暮秋雨落夜三更