前言:
在前段时间,学习JMM以及synchronize、volatile和ReentrantLock之后,本着好奇的心思,想研究一下juc包下的其他并发控制工具,于是乎,便着手Semaphore进行研究。
一、什么是Semaphore
Semaphore,翻译过来也叫信号量,也是JUC包下一个重要的并发工具,其核心功能是为了限制并发线程数量,也可以理解为限流。
虽然说,翻译过来称之为信号量,但还是觉得叫许可管理器,更贴切一些,因为都是过来一个线程,申请一个许可,有许可就给,没许可就阻塞。线程用完许可就进行回收。
再通俗一点说,Semaphore就是synchronize 或者 ReentrantLock的衍生+升级版本的并发控制工具。
二、Semaphore的作用
而Semaphore最主要的作用还是限制并发线程数,这一点,其实可以在典型的秒杀场景里实现,比如就只有100个线程允许执行,超过一百个,就阻塞。
但这种方式,在分布式场景里,并不适用,而分布式系统往往都是在网关层面进行限流控制,这里不展开细讲。
三、Semaphore源码分析
1、 Semaphore内部结构
从上图也可以看出,其实Semaphore只实现了序列化接口,但其内部有两个类:
1)FairSync :公平模式AQS同步器
2)NonfairSync:非公平模式AQS同步器
且这两个同步器,其父类Sync通过继承抽象类AQS(AbstractQueueSynchronizer)实现基本功能,再由上述两个子类实现公平和非公平模式的同步功能,这一点和ReentrantLock的实现方式可以说非常类似,但也有不同。不同点在于其构造函数入参以及对state的读写控制,下文将展开详细描述。
2 Semaphore关键方法
1)内部类Sync
// java.util.concurrent.Semaphore.Sync
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;
// 构造方法,传入许可次数,放入state中
Sync(int permits) {
setState(permits);
}
// 获取许可次数
final int getPermits() {
return getState();
}
// 非公平模式尝试获取许可
final int nonfairTryAcquireShared(int acquires) {
// 自旋模式 获取许可
for (;;) {
// 看看还有几个许可
int available = getState();
// 减去这次需要获取的许可还剩下几个许可
int remaining = available - acquires;
// 如果剩余许可小于0了则直接返回
// 如果剩余许可不小于0,则尝试原子更新state的值,成功了返回剩余许可
if (remaining < 0 ||
compareAndSetState(available, remaining)) // cas方式 更新剩余许可数量
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");
// 如果原子更新state的值成功,就说明释放许可成功,则返回true
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");
// 原子更新state的值,成功了返回true
if (compareAndSetState(current, next))
return;
}
}
// 销毁许可
final int drainPermits() {
for (;;) {
// 看看还有几个许可
int current = getState();
// 如果为0,直接返回
// 如果不为0,把state原子更新为0
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
}
通过阅读Sync这个内部类可以看到,所谓的许可,就是一个从外部传递进来的int类型变量,Sync接受这个变量之后,并将其赋值给state,而这个过程是Semaphore在后续获取、释放许可等操作的基础前提。
而通过对Sync中提供的方法源码进行阅读可以发现,所谓的获取 or 销毁许可,就是对state变量的读写,当然这个读写必须是通过cas方式进行,来保证多线程下state的正确性。总结一下,Sync类主要做了以下几方面的事情:
(1)许可是在构造方法时传入的;
(2)许可存放在状态变量state中;
(3)尝试获取一个许可的时候,则state的值减1;
(4)当state的值为0的时候,则无法再获取许可;
(5)释放一个许可的时候,则state的值加1;
(6)许可的个数可以动态改变;
2)内部类NonfairSync
介绍了Sync之后,再来看看其子类NonfairSync(非公平模式同步器),其内部实现原理如下所示:
// java.util.concurrent.Semaphore.NonfairSync
static final class NonfairSync extends Sync {
private static final long serialVersionUID = -2694183684443567898L;
// 构造方法,调用父类的构造方法
NonfairSync(int permits) {
super(permits);
}
// 尝试获取许可,调用父类的nonfairTryAcquireShared()方法
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}
从源码第10行可以知道,非公平模式下,会直接调用父类的nonfairTryAcquireShared()方法去尝试获取许可。
3)内部类FairSync
接下来,再看看FairSync,源码如下:
// java.util.concurrent.Semaphore.FairSync
static final class FairSync extends Sync {
private static final long serialVersionUID = 2014338818796000944L;
// 构造方法,调用父类的构造方法
FairSync(int permits) {
super(permits);
}
// 尝试获取许可
protected int tryAcquireShared(int acquires) {
for (;;) {
// 公平模式需要检测是否前面有排队的
// 如果有排队的直接返回失败
if (hasQueuedPredecessors())
return -1;
// 没有排队的再尝试更新state的值
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
通过名称,大概也可以知道,FairSync是基于一种公平模式下的同步器,而当时我有所疑惑的是,如何实现所谓的公平模式?
其实读完之后,可以发现,公平模式主要借助队列FIFO方式进行实现,具体可以看hasQueuedPredecessors()方法。这也是该模式与非公平模式获取许可的核心区别。
其中hasQueuePredecessors()是顶层父类AQS提供的方法,用于检测当前节点入队后,该节点是否为头结点。
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
4)构造方法
通过Semaphore的构造方法可知,Semaphore在初始化时,默认使用非公平模式去获取一个Semaphore的实例,当然,可以通过指定公平/非公平的方式来获取一个Semaphore实例。而入参permit就是前文所说的,许可数量
// 构造方法,创建时要传入许可次数,默认使用非公平模式
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
// 构造方法,需要传入许可次数,及是否公平模式
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
5)Semaphore中常用方法
1)acquire();
通过可中断方式获取一个许可,如果尝试获取许可失败,则会进入到AQS队列中排队。
public void acquire() throws InterruptedException { sync.acquireSharedInterruptibly(1); }
2)acquireUninterruptibly()方法
获取一个许可,非中断方式,如果尝试获取许可失败,会进入AQS的队列中排队。
public void acquireUninterruptibly() { sync.acquireShared(1); }
3)tryAcquire()方法
尝试获取一个许可,使用Sync的非公平模式尝试获取许可方法,不论是否获取到许可都返回,只尝试一次,不会进入队列排队。
public boolean tryAcquire() {
return sync.nonfairTryAcquireShared(1) >= 0;
}
4)tryAcquire(long timeout, TimeUnit unit)方法
尝试获取一个许可,先尝试一次获取许可,如果失败则会等待timeout时间,这段时间内都没有获取到许可,则返回false,否则返回true;
public boolean tryAcquire(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
5)release()方法
释放一个许可,释放一个许可时state的值会加1,并且会唤醒下一个等待获取许可的线程。
public void release() {
sync.releaseShared(1);
}
6)acquire(int permits)方法
一次获取多个许可,可中断方式。
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
7)acquireUninterruptibly(int permits)方法
一次获取多个许可,非中断方式。
public void acquireUninterruptibly(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireShared(permits);
}
8)tryAcquire(int permits)方法
一次获取多个许可,可中断方式。
public void acquire(int permits) throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireSharedInterruptibly(permits);
}
9)acquireUninterruptibly(int permits)方法
一次获取多个许可,非中断方式
public void acquireUninterruptibly(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.acquireShared(permits);
}
10)tryAcquire(int permits)方法
一次尝试获取多个许可,只尝试一次。
public boolean tryAcquire(int permits) {
if (permits < 0) throw new IllegalArgumentException();
return sync.nonfairTryAcquireShared(permits) >= 0;
}
11)tryAcquire(int permits, long timeout, TimeUnit unit)方法
尝试获取多个许可,并会等待timeout时间,这段时间没获取到许可则返回false,否则返回true。
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
throws InterruptedException {
if (permits < 0) throw new IllegalArgumentException();
return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}
12)release(int permits)方法
一次释放多个许可,state的值会相应增加permits的数量。
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
13)availablePermits()方法
获取可用许可的次数
public int availablePermits() {
return sync.getPermits();
}
14)drainPermits()方法
销毁当前可用的许可次数,对于已经获取的许可没有影响,会把当前剩余的许可全部销毁。换句话说,有10个许可,被取走了3个,剩下七个,此时调用该方法,会全部销毁7个许可,而已经取走的三个许可则不受影响
public int drainPermits() {
return sync.drainPermits();
}
15)reducePermits(int reduction)方法
减少许可的次数。
protected void reducePermits(int reduction) {
if (reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}
虽然列了这么15个方法,有点杂乱,但是可以发现的是,本质上都是对获取/释放许可,销毁/减少许可等底层基础方法的封装和调用。
如tryAcquire() 和 tryAcquire(permit),其区别就是尝试一次获取单个许可和尝试获取多个许可的区别,所以,本质上来说,理解了Sync、NonFairSync和FairSync这三个类提供的方法后,对于后续Semaphore提供的方法的解读,无非就是对这些类里提供的方法的扩充和封装。
而这里需要注意的是,在阅读源码的时候,中断/非中断这个字眼重复出现,其实还是要回归到AQS里去理解,后文将继续展开描述。
3 Semaphore实战示例
package servlet;
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
/**
* @ClassName SemaphoreTest
* @Descrpition
* @Author
* @Date 2019/8/13 上午10:17
* @Version 1.0
**/
public class SemaphoreTest {
//假设有一个车库 拥有有3个停车位 那么permit=3 为允许停放车辆数,即驶入许可
private static final Semaphore semaphore = new Semaphore(3);
private static final ExecutorService executorService = Executors.newCachedThreadPool();
private static class CarThread implements Runnable {
private String name;
private String carNumber;
public CarThread(String name, String carNumber) {
this.name = name;
this.carNumber = carNumber;
}
@Override
public void run() {
try {
// 获取进入车库许可
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + ":请注意,车牌号:" + carNumber + "进入车库,当前时间" + Timestamp.valueOf(LocalDateTime.now()));
Thread.sleep(2000);
System.out.println("当前车库车位空余数:" + semaphore.availablePermits());
System.out.println(carNumber + "驶出车库,当前时间:" + Timestamp.valueOf(LocalDateTime.now()));
semaphore.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
String[] name = {"Car1", "Car2", "Car3", "Car4", "Car5", "Car6", "Car7"};
String[] carNumber = {"浙A99999", "浙A88888", "浙A77777", "浙A123333", "浙A123111", "浙A66666", "浙A55555"};
for (int i = 0; i < 7; i++) {
CarThread carThread = new CarThread(name[i], carNumber[i]);
executorService.submit(carThread);
}
}
}
运行结果如下图所示:
/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/bin/java "-javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=61341:/Applications/IntelliJ IDEA.app/Contents/bin" -Dfile.encoding=UTF-8 -classpath /Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/charsets.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/deploy.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/cldrdata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/dnsns.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/jaccess.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/jfxrt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/localedata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/nashorn.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunec.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunjce_provider.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunpkcs11.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/zipfs.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/javaws.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jce.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jfr.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jfxswt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jsse.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/management-agent.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/plugin.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/resources.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/rt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/ant-javafx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/dt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/javafx-mx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/jconsole.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/packager.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/sa-jdi.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/tools.jar:/Users/qudi/Documents/JavaStudy/MyServlet/out/production/MyServlet:/Users/qudi/Downloads/devEnv/apache-tomcat-8.5.42/lib/jsp-api.jar:/Users/qudi/Downloads/devEnv/apache-tomcat-8.5.42/lib/servlet-api.jar servlet.SemaphoreTest
pool-1-thread-2:请注意,车牌号:浙A88888进入车库,当前时间2019-08-13 10:43:58.43
pool-1-thread-1:请注意,车牌号:浙A99999进入车库,当前时间2019-08-13 10:43:58.43
pool-1-thread-3:请注意,车牌号:浙A77777进入车库,当前时间2019-08-13 10:43:58.43
当前车库车位空余数:0
当前车库车位空余数:0
当前车库车位空余数:0
浙A88888驶出车库,当前时间:2019-08-13 10:44:00.436
浙A77777驶出车库,当前时间:2019-08-13 10:44:00.436
浙A99999驶出车库,当前时间:2019-08-13 10:44:00.436
pool-1-thread-4:请注意,车牌号:浙A123333进入车库,当前时间2019-08-13 10:44:00.436
pool-1-thread-5:请注意,车牌号:浙A123111进入车库,当前时间2019-08-13 10:44:00.436
pool-1-thread-6:请注意,车牌号:浙A66666进入车库,当前时间2019-08-13 10:44:00.437
当前车库车位空余数:0
当前车库车位空余数:0
当前车库车位空余数:0
浙A123111驶出车库,当前时间:2019-08-13 10:44:02.438
浙A123333驶出车库,当前时间:2019-08-13 10:44:02.439
浙A66666驶出车库,当前时间:2019-08-13 10:44:02.438
pool-1-thread-7:请注意,车牌号:浙A55555进入车库,当前时间2019-08-13 10:44:02.439
当前车库车位空余数:2
浙A55555驶出车库,当前时间:2019-08-13 10:44:04.442
其实观察一下,就可以发现,在main方法中,采用for循环的方式,创建线程并提交给线程池执行,但从输出结果来看,车库车位空余数量并没有与我预期的结果一致,简单分析了一下,是因为在Semaphore.acquire()和Semaphore.release()这两个方法之间的代码,并非像Lock那样同一时间只有一个线程执行,换句话说,是因为并发执行造成车库空余车位数量不准确的缘故,如果想要改进的话,可以配合ReentrantLock来实现。
四、个人感想
读了Semaphore之后,有了几点感悟吧:
1、Semaphore是信号量,用于管理一组资源。其内部是基于AQS的共享模式,AQS的状态表示许可证的数量,在许可证数量不够时,线程将会被挂起;而一旦有一个线程释放一个资源,那么就有可能重新唤醒等待队列中的线程继续执行。
2、读了Semaphore之后,发现还是需要回归到AQS上,去理解,并在此基础上进一步深入阅读,触类旁通。
3、在Semaphore获取/释放许可这个动作之间,并非原子操作,与ReentrantLock的lock和unlock是有本质区别的。