Semaphore(信号量)用来控制同时访问特定资源的线程数量,它通过协调各个线程,以保证合理的使用公共资源。
Semaphore提供了一个许可证的概念,可以把这个许可证看作公共汽车车票,只有成功获取车票的人才能够上车,并且车票是有一定数量的,不可能毫无限制的发下去,这样就会导致公交车超载。所以当车票发完的时候(公交车以满载),其他人就只能等下一趟车了。如果中途有人下车,那么他的位置将会空闲出来,因此如果这时其他人想要上车的话就又可以获得车票了。
构造函数
Semaphore类提供了2种构造函数,分别如下:
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
这两个构造方法,都必须提供许可的数量,第二个构造方法可以指定是公平模式还是非公平模式,默认非公平模式。
在ReentrantLock中公平锁和非公平锁获取锁机制的差别:对于公平锁而言,如果当前线程不在CLH队列的头部,则需要排队等候,而非公平锁则不同,它无论当前线程处于CLH队列的何处都会直接获取锁。所以公平信号量和非公平信号量的区别也一样。
获取许可证
Semaphore类提供了4种获取许可证的方法,分别如下:
//获取一个许可证(响应中断),在没有可用的许可证时当前线程被阻塞。
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
//获取一个许可证(不响应中断)
public void acquireUninterruptibly() {
sync.acquireShared(1);
}
//尝试获取许可证(非公平获取),立即返回结果(非阻塞)。
public boolean tryAcquire() {
return sync.nonfairTryAcquireShared(1) >= 0;
}
//尝试获取许可证(定时获取)
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}
下面我们一起看看,acquire()是如何获取许可证的? 其源码如下:
public void acquire() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
acquireSharedInterruptibly方法首先就是去调用tryAcquireShared方法去尝试获取,tryAcquireShared在AQS里面是抽象方法,FairSync和NonfairSync这两个派生类实现了该方法的逻辑。FairSync实现的是公平获取的逻辑,而NonfairSync实现的非公平获取的逻辑。
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 1192457210091910933L;
Sync(int permits) {
setState(permits);
}
final int getPermits() {
return getState();
}
// 非公平方式尝试获取
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
// 获取可用许可证
int available = getState();
// 获取剩余许可证
int remaining = available - acquires;
// 1.如果remaining小于0则直接返回remaining
// 2.如果remaining大于0则先更新同步状态再返回remaining
if (remaining < 0 ||
compareAndSetState(available, remaining))
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");
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");
if (compareAndSetState(current, next))
return;
}
}
final int drainPermits() {
for (;;) {
int current = getState();
if (current == 0 || compareAndSetState(current, 0))
return current;
}
}
}
// 非公平同步器
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);
}
}
// 公平同步器
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;
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
}
-
非公平获取锁的逻辑是先取出当前同步状态(同步状态表示许可证个数),将当前同步状态减去参入的参数,如果结果不小于0的话证明还有可用的许可证,那么就直接使用CAS操作更新同步状态的值,最后不管结果是否小于0都会返回该结果值。
-
公平获取锁的逻辑仅仅是在此之前先去调用hasQueuedPredecessors方法判断同步队列是否存在排队,如果有的话就直接返回-1表示获取失败,否则继续执行和非公平获取一样的步骤。
释放许可证
Semaphore类提供了2种释放许可证方法,分别如下:
public void release() {
sync.releaseShared(1);
}
public void release(int permits) {
if (permits < 0) throw new IllegalArgumentException();
sync.releaseShared(permits);
}
调用release方法是释放一个许可证,它的操作很简单,就调用了AQS的releaseShared方法。
//释放锁的操作(共享模式)
public final boolean releaseShared(int arg) {
//1.尝试去释放锁
if (tryReleaseShared(arg)) {
//2.如果释放成功就唤醒其他线程
doReleaseShared();
return true;
}
return false;
}
AQS的releaseShared方法首先调用tryReleaseShared方法尝试释放锁,其实现逻辑在子类Sync里面。
// 尝试释放操作
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;
}
}
tryReleaseShared方法里面采用for循环进行自旋,首先获取同步状态,将同步状态加上传入的参数,然后以CAS方式更新同步状态,更新成功就返回true并跳出方法,否则就继续循环直到成功为止。
动手写个连接池
下面我们就来利用Semaphore实现一个简单的数据库连接池,通过这个例子希望读者们能更加深入的掌握Semaphore的运用。
public class ConnectPool {
//连接池大小
private int size;
//数据库连接集合
private Connect[] connects;
//连接状态标志
private boolean[] connectFlag;
//剩余可用连接数
private volatile int available;
//信号量
private Semaphore semaphore;
//构造器
public ConnectPool(int size) {
this.size = size;
this.available = size;
semaphore = new Semaphore(size, true);
connects = new Connect[size];
connectFlag = new boolean[size];
initConnects();
}
//初始化连接
private void initConnects() {
//生成指定数量的数据库连接
for(int i = 0; i < this.size; i++) {
connects[i] = new Connect();
}
}
//获取数据库连接
private synchronized Connect getConnect(){
for(int i = 0; i < connectFlag.length; i++) {
//遍历集合找到未使用的连接
if(!connectFlag[i]) {
//将连接设置为使用中
connectFlag[i] = true;
//可用连接数减1
available--;
System.out.println("【"+Thread.currentThread().getName()+"】以获取连接 剩余连接数:" + available);
//返回连接引用
return connects[i];
}
}
return null;
}
//获取一个连接
public Connect openConnect() throws InterruptedException {
//获取许可证
semaphore.acquire();
//获取数据库连接
return getConnect();
}
//释放一个连接
public synchronized void release(Connect connect) {
for(int i = 0; i < this.size; i++) {
if(connect == connects[i]){
//将连接设置为未使用
connectFlag[i] = false;
//可用连接数加1
available++;
System.out.println("【"+Thread.currentThread().getName()+"】以释放连接 剩余连接数:" + available);
//释放许可证
semaphore.release();
}
}
}
//剩余可用连接数
public int available() {
return available;
}
}
测试代码:
public class TestThread extends Thread {
private static ConnectPool pool = new ConnectPool(3);
@Override
public void run() {
try {
Connect connect = pool.openConnect();
Thread.sleep(100); //休息一下
pool.release(connect);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
for(int i = 0; i < 10; i++) {
new TestThread().start();
}
}
}
使用一个数组来存放数据库连接的引用,在初始化连接池的时候会调用initConnects方法创建指定数量的数据库连接,并将它们的引用存放到数组中,此外还有一个相同大小的数组来记录连接是否可用。
每当外部线程请求获取一个连接时,首先调用semaphore.acquire()方法获取一个许可证,然后将连接状态设置为使用中,最后返回该连接的引用。许可证的数量由构造时传入的参数决定,每调用一次semaphore.acquire()方法许可证数量减1,当数量减为0时说明已经没有连接可以使用了,这时如果其他线程再来获取就会被阻塞。每当线程释放一个连接的时候会调用semaphore.release()将许可证释放,此时许可证的总量又会增加,代表可用的连接数增加了,那么之前被阻塞的线程将会醒来继续获取连接,这时再次获取就能够成功获取连接了。
作者:codersm
链接:https://www.jianshu.com/p/3c419bbeb0dd
來源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。