欢迎大家关注 github.com/hsfxuebao/j… ，希望对大家有所帮助，要是觉得可以的话麻烦给点一下Star哈
1. Semaphore 定义
Semaphore 主要用于限量控制并发执行代码的工具类, 其内部通过 一个 permit 来进行定义并发执行的数量, 其实可以理解为一个 限制数量的 ReadLock 获取.
Semaphore 主要特点:
- Semaphore 方法的实现通过 Sync(AQS的继承类)代理来实现
- 支持公平与非公平模式, 都是在AQS的子类里面进行, 主要区分在 tryAcquire 里面
先看一个简单的 demo
/**
* 描述： 演示Semaphore用法
*/
public class SemaphoreDemo {
static Semaphore semaphore = new Semaphore(5, true);
public static void main(String[] args) {
ExecutorService service = Executors.newFixedThreadPool(50);
for (int i = 0; i < 100; i++) {
service.submit(new Task());
}
service.shutdown();
}
static class Task implements Runnable {
@Override
public void run() {
try {
semaphore.acquire(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "拿到了许可证");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "释放了许可证");
semaphore.release(3);
}
}
}
执行结果
pool-1-thread-1拿到了许可证
pool-1-thread-1释放了许可证
pool-1-thread-2拿到了许可证
pool-1-thread-2释放了许可证
pool-1-thread-3拿到了许可证
pool-1-thread-3释放了许可证
pool-1-thread-4拿到了许可证
。。。。。
执行步骤:
上面的代码不好直接看出, 但可以这样理解, 有一段代码, 再
2. 构造函数
Semaphore 的功能均由内部类 NonfairSync, FairSync 代理来实现
/**
* 使用非公平版本构件 Semaphore
*/
public KSemaphore(int permits){
sync = new NonfairSync(permits);
}
/**
* 指定版本构件 Semaphore
*/
public KSemaphore(int permits, boolean fair){
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
3. 内部类 Sync
/**
* Synchronization implementation for semaphore. Uses AQS state
* to represent permits. Subclassed into fair and nonfair
* versions
*/
/** AQS 的子类主要定义获取释放 lock */
abstract static class Sync extends KAbstractQueuedSynchronizer{
private static final long serialVersionUID = 1192457210091910933L;
/**
* 指定 permit 初始化 Semaphore
*/
Sync(int permits){
setState(permits);
}
/**
* 返回剩余 permit
*/
final int getPermits(){
return getState();
}
/**
* 获取 permit
*/
final int nonfairTryAcquireShared(int acquires){
for(;;){
int available = getState();
int remaining = available - acquires; // 判断获取 acquires 的剩余 permit 数目
if(remaining < 0 ||
compareAndSetState(available, remaining)){ // cas改变 state
return remaining;
}
}
}
/**
* 释放 lock
*/
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)){ // cas改变 state
return true;
}
}
}
final void reducePermits(int reductions){ // 减少 permits
for(;;){
int current = getState();
int next = current - reductions;
if(next > current){ // underflow
throw new Error(" Permit count underflow ");
}
if(compareAndSetState(current, next)){
return;
}
}
}
/** 将 permit 置为 0 */
final int drainPermits(){
for(;;){
int current = getState();
if(current == 0 || compareAndSetState(current, 0)){
return current;
}
}
}
}
4. 内部类 FairSync, NonfairSync
这两个类均继承 Sync, 两者的区别主要在于在获取时判断是否有线程在 AQS 的 Sync Queue 里面进行等待获取
/**
* Nonfair version
*/
/** 非公平版本获取 permit */
static final class NonfairSync extends Sync{
private static final long serialVersionUID = -2694183684443567898L;
NonfairSync(int permits) {
super(permits);
}
@Override
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}
/**
* Fair version
*/
/** 公平版本获取 permit */
static final class FairSync extends Sync{
private static final long serialVersionUID = 3245289457313211085L;
FairSync(int permits) {
super(permits);
}
/**
* 公平版本获取 permit 主要看是否由前继节点
*/
@Override
protected int tryAcquireShared(int acquires) {
for(;;){
if(hasQueuedPredecessors()){ // 1. 判断是否Sync Queue 里面是否有前继节点
return -1;
}
int available = getState();
int remaining = available - acquires;
if(remaining < 0 ||
compareAndSetState(available, remaining)){ // 2. cas 改变state
return remaining;
}
}
}
}
5. permit 获取方法
下面这些方法主要通过内部类 Sync, FairSync, NonFairSync 来进行实现
/**
* 调用 acquireSharedInterruptibly 响应中断的方式获取 permit
*/
public void acquire() throws InterruptedException{
sync.acquireSharedInterruptibly(1);
}
/**
* 调用 acquireUninterruptibly 非响应中断的方式获取 permit
*/
public void acquireUninterruptibly(){
sync.acquireShared(1);
}
/**
* 尝试获取 permit
*/
public boolean tryAcquire(){
return sync.nonfairTryAcquireShared(1) >= 0;
}
/**
* 尝试的获取 permit, 支持超时与中断
*/
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException{
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
/**
* 支持中断的获取permit
*/
public void acquire(int permits) throws InterruptedException{
if(permits < 0){
throw new IllegalArgumentException();
}
sync.acquireSharedInterruptibly(permits);
}
/**
* 不响应中断的获取 permit
*/
public void acquireUninterruptibly(int permits){
if(permits < 0) throw new IllegalArgumentException();
sync.acquireShared(permits);
}
/**
* 尝试获取 permit
*/
public boolean tryAcquire(int permits){
if(permits < 0) throw new IllegalArgumentException();
return sync.nonfairTryAcquireShared(permits) >= 0;
}
/**
* 尝试 支持超时机制, 支持中断 的获取 permit
*/
public boolean tryAcquire(int permits, long timout, TimeUnit unit) throws InterruptedException{
if(permits < 0) throw new IllegalArgumentException();
return sync.tryAcquireSharedNanos(permits, unit.toNanos(timout));
}
6. permit 释放方法
/**
* 释放 permit
*/
public void release(){
sync.releaseShared(1);
}
/**
* 释放 permit
*/
public void release(int permits){
if(permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
7. Semaphore 工具类方法
/**
* 返回可用的 permit
*/
public int availablePermits(){
return sync.getPermits();
}
/**
* 消耗光 permit
*/
public int drainPermits(){
return sync.drainPermits();
}
/**
* 减少 reduction 个permit
*/
protected void reducePermits(int reduction){
if(reduction < 0) throw new IllegalArgumentException();
sync.reducePermits(reduction);
}
/**
* 判断是否是公平版本
*/
public boolean isFair(){
return sync instanceof FairSync;
}
/**
* 返回 AQS 中 Sync Queue 里面的等待线程
*/
public final boolean hasQueuedThreads(){
return sync.hasQueuedThreads();
}
/**
* 返回 AQS 中 Sync Queue 里面的等待线程长度
*/
public final int getQueueLength(){
return sync.getQueueLength();
}
/**
* 返回 AQS 中 Sync Queue 里面的等待线程
*/
protected Collection<Thread> getQueueThreads(){
return sync.getQueuedThreads();
}
8. 总结
Semaphore 通过 AQS中的 state 来进行控制 permit 的获取控制, 其实它就是一个限制数量的 ReadLock; 但要真正理解 Semaphore, 还需要理解 AbstractQueuedSynchronizer
参考
Semaphore 源码分析 (基于Java 8)
Java 8 源码分析 AbstractQueuedSynchronizer
Java 8 源码分析 ReentrantReadWriteLock
Java多线程之JUC包：Semaphore源码学习笔记
