What is Semaphore
一个并发工具Semaphore,位于java.util.concurrent
下面,在并发家族里面充当着工具类的角色。
那么Semaphore作为一个工具,有什么作用呢?
控制容量,就好比一个停车场,容量为100,已经听了50,所以此时还能再停50,如果已经停了100的话,那么外面的车就进不去了,只能在外面等。此时当有车出来时,才能有车进去。
具体实现
首先看Semaphore的定义:
public class Semaphore implements java.io.Serializable
很简单定义,就实现了Serializable。里面则是通过AbstractQueuedSynchronizer来实现的,本质是一把共享锁,但是会控制量,也就是控制并发访问量,其他超出的,就会在队列中挂起,处于等待状态,具体可看:Java并发学习(三)-AbstractQueuedSynchronizer 。
里面实现了两种锁获取的机制,即公平锁和非公平锁。
看看其内部主要构造代码:
// 自己内部基于AQS实现的同步器。
private final Sync sync;
abstract static class Sync extends AbstractQueuedSynchronizer {
/**
* permits也就是state变量。
* @param permits
*/
Sync(int permits) {
setState(permits);
}
final int getPermits() {
return getState();
}
...
}
最初构造方法传入的permits,就用于父类去初始化state变量。以后每次释放或者获取,都是通过父类调用CAS原子操作实现。
以下分别以公平锁模式和非公平锁模式来说明获取和释放锁。
公平锁FairSync
获取锁:
protected int tryAcquireShared(int acquires) {
for (;;) {
//判断head后面,是否有代执行节点
if (hasQueuedPredecessors())
return -1;
int available = getState();
int remaining = available - acquires;
//修改执行状态
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
上述代码中,调用了hasQueuedPredecessors,下面主要看这个方法:
public final boolean hasQueuedPredecessors() {
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());
}
Java doc中对其的注释就是,查看是否队列中是否,还有其他的线程整个等待获取锁,也就是在head(AQS设计当前获取锁的为head)后面,是否有一个node在等待获取锁,并且此node不是当前线程的node。
这样一来,公平锁的具体意思就是,当任意线程性要去获取锁的时候,首先看下有没有排队的,有排队的话,我就获取不到,我得等。
而在AQS实现里面,当获取不到时候进行自旋时,就会判断该线程需不需要挂起并进行排队,放到队列里面。这里就不深讲,可以去看AQS相关。
非公平锁NonfairSync
非公平锁,相对来说比公平锁实现要简单很多,它直接去尝试更改state状态,而不询问是否有排队的。
final int nonfairTryAcquireShared(int acquires) {
//阻塞性,去更改state。非公平,也就是强行去更改,而不是通过队列来更改。
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
释放锁
释放锁,则是直接调用父类方法,将state变量进行更改:
public void release() {
sync.releaseShared(1);
}
再看父类的releaseShared:
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
调用子类的: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");
if (compareAndSetState(current, next))
return true;
}
}
而doReleaseShared方法则是唤醒下一个节点,让他自己去竞争锁,这里就和公平和非公平无关了。
用途&例子
前面讲过,Semaphore主要用于访问量容量的控制,比如数据库连接。假如有一个需求,要读取几万个文件的数据,因为都是IO密集型任务,我们可以启动几十个线程并发的读取,但是如果读到内存后,还需要存储到数据库中,而数据库的连接数只有5个,这时我们必须控制只有五个线程同时获取数据库连接保存数据,否则会报错无法获取数据库连接。这个时候,我们就可以使用Semaphore来做流控,代码如下:
public class SemaphoreTest {
private static final int THREAD_COUNT = 30;
private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);
//设置Semaphore信号量
private static Semaphore s = new Semaphore(5);
public static void main(String[] args) {
for (int i = 0; i < THREAD_COUNT; i++) {
threadPool.execute(new Runnable() {
@Override
public void run() {
try {
//需要获取信号量
s.acquire();
System.out.println("save data");
//释放信号量
s.release();
} catch (InterruptedException e) {
}
}
});
}
threadPool.shutdown();
}
}
参考资料:
1. https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Semaphore.html
2. http://ifeve.com/concurrency-semaphore/