前言
在前几篇文章中,
聊聊并发:(十三)concurrent包并发辅助类之CountDownLatch源码分析
聊聊并发:(十二)concurrent包并发辅助类之CyclicBarrier源码分析
聊聊并发:(七)concurrent包之AbstractQueuedSynchronizer分析
我们介绍了concurrent包中的并发控制辅助类——CyclicBarrier与CountDownLatch,这两个都可以用于控制线程之间的调度运行,本篇,我们继续介绍另外一个比较常用的并发辅助类——Semaphore介绍。
Semaphore介绍
Semaphore是一个计数信号量。从概念上讲,信号量维护了一个许可集。如有必要,在许可可用前会阻塞每一个 acquire(),然后再获取该许可。每个 release() 添加一个许可,从而可能释放一个正在阻塞的获取者。
Semaphore 通常用于限制可以访问某些资源(物理或逻辑的)的线程数目。
通俗点来讲,Semaphore可以理解为一个流量控制器,只允许指定数目的线程拿到许可,继续执行,当有其他线程再希望拿到许可时,需要阻塞等待,直到拿到许可的线程执行完毕后,释放许可,其他线程才可以获取到许可,进行执行。
Semaphore 有两种模式,即公平模式与非公平模式,可以通过构造方法进行指定。
Semaphore(int permits)
创建具有给定的许可数和非公平的公平设置的 Semaphore。
---------------------------------------------------------------------
Semaphore(int permits, boolean fair)
创建具有给定的许可数和给定的公平设置的 Semaphore。
在非公平模式下,不对线程获取许可的顺序做任何保证,即一个线程可能刚刚获取完许可并释放许可,可以立刻再次获取许可。
在公平模式下,对于任何调用获取方法的线程而言,都按照处理它们调用这些方法的顺序(即先进先出;FIFO)来选择线程、获得许可。
我们来看一下Semaphore 比较重要的几个方法:
void acquire()
从此信号量获取一个许可,在提供一个许可前一直将线程阻塞,否则线程被中断。
void acquire(int permits)
从此信号量获取给定数目的许可,在提供这些许可前一直将线程阻塞,或者线程已被中断。
void release()
释放一个许可,将其返回给信号量。
void release(int permits)
释放给定数目的许可,将其返回到信号量。
Semaphore使用示例
public class SemaphoreDemo {
public static void main(String[] args) {
Semaphore semaphore = new Semaphore(1);
ExecutorService executors = Executors.newFixedThreadPool(3);
for (int i = 0; i < 3; i++) {
executors.execute(() -> {
System.out.println("线程池A,启动线程,当前线程名称:" + Thread.currentThread().getName());
try {
System.out.println("线程池A,当前线程名称:" + Thread.currentThread().getName() + ",准备尝试获取许可");
semaphore.acquire();
System.out.println("线程池A,当前线程名称:" + Thread.currentThread().getName() + ",获取许可成功");
Thread.sleep(5 * 1000);
} catch (Exception e) {
e.printStackTrace();
}
semaphore.release();
System.out.println("线程池A,当前线程名称:" + Thread.currentThread().getName() + "释放许可成功");
});
}
}
}
输出:
线程池A,启动线程,当前线程名称:pool-1-thread-2
线程池A,启动线程,当前线程名称:pool-1-thread-1
线程池A,当前线程名称:pool-1-thread-1,准备尝试获取许可
线程池A,启动线程,当前线程名称:pool-1-thread-3
线程池A,当前线程名称:pool-1-thread-1,获取许可成功
线程池A,当前线程名称:pool-1-thread-2,准备尝试获取许可
线程池A,当前线程名称:pool-1-thread-3,准备尝试获取许可
线程池A,当前线程名称:pool-1-thread-1释放许可成功
线程池A,当前线程名称:pool-1-thread-2,获取许可成功
线程池A,当前线程名称:pool-1-thread-2释放许可成功
线程池A,当前线程名称:pool-1-thread-3,获取许可成功
线程池A,当前线程名称:pool-1-thread-3释放许可成功
上面的实例简单演示了Semaphore的用法,我们初始化了一个Semaphore,初始化大小置为1,启动3个线程,线程只有获取到Semaphore的许可后,才可以继续执行,否则进入阻塞等待,Semaphore被一个线程获取许可后,只有其释放掉资源后,其他线程才可以继续获取。
Semaphore源码实现
Semaphore的实现同样是基于AQS的,通过重写AQS的抽象方法,实现其功能,我们来看一下它的实现:
public class Semaphore implements java.io.Serializable {
private static final long serialVersionUID = -3222578661600680210L;
private final Sync sync;
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;
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;
}
}
}
/**
* NonFair version
*/
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);
}
}
/**
* Fair version
*/
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;
}
}
}
.......
这里我们只给出一小部分实现,如果看过之前系列文章的读者可以一眼看出,Semaphore的实现基本与另外几个并发辅助工具类差不多,内部实现一个同步器,去继承AQS,重写其模板方法,实现自己的功能。
Semaphore支持两种模式,一种是公平模式,一种是非公平模式,在前面我们已经提到了,这部分的实现也是基于AQS。
由于之前的文章中对AQS家族工具类已经有了很详细的分析,本篇我们就着重介绍两个方法的实现。
acquire()
我们首先来看一下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);
}
acquire()是调用了AQS的模板方法进行的实现,分为公平模式与非公平模式,我们来分别看一下它们的实现:
公平模式:
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;
}
}
}
非公平模式:
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);
}
}
final int nonfairTryAcquireShared(int acquires) {
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
公平模式下,会检查当前同步队列中是否存在前驱节点,如果存在,直接将当前线程加入同步队列中,由于之前介绍AQS与锁的时候已经详细分析过这里的实现,此处不再赘述,感兴趣的朋友可以看一下之前的文章。
非公平模式下,将不会保证线程争抢资源的先后顺序,每次线程争抢同步资源时,将同步资源初始化值减一,当同步资源数小于0时,将当前线程放入同步队列中进行等待。
release()
public void release() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
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;
}
}
释放资源的操作较为简单,将同步资源状态增量(其实就是加1),CAS设置同步资源状态,唤醒同步资源线程。
其他方法介绍
源码分析部分,我们只介绍acquire() 和 release() 这两个方法,这里我们简单介绍一下其他的方法:
acquireUninterruptibly()
从此信号量中获取许可,在有可用的许可前将其阻塞。
availablePermits()
返回此信号量中当前可用的许可数。
getQueuedThreads()
返回一个 collection,包含可能等待获取的线程。
getQueueLength()
返回正在等待获取的线程的估计数目。
tryAcquire(int permits)
仅在调用时此信号量中有给定数目的许可时,才从此信号量中获取这些许可。
tryAcquire(int permits, long timeout, TimeUnit unit)
如果在给定的等待时间内此信号量有可用的所有许可,并且当前线程未被中断,则从此信号量获取给定数目的许可。
Semaphore VS CountDownLatch VS CyclicBarrier
Semaphore、CountDownLatch、CyclicBarrier这三个类都是用于实现并发辅助的工具类,但是它们在使用场景上有略微的区别,这里我们横向对比一下:
-
CountDownLatch和CyclicBarrier都能够实现线程之间的等待,只不过它们侧重点不同:
- CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后,它才执行;
- 而CyclicBarrier一般用于一组线程互相等待至某个状态,然后这一组线程再同时执行;
- 另外,CountDownLatch是不能够重用的,而CyclicBarrier是可以重用的。
-
Semaphore其实和锁有点类似,它一般用于控制对某组资源的访问权限,而锁是控制对某个资源的访问权限。
结语
本篇,我们介绍了Semaphore,同样是AQS家族的实现类,用于并发辅助的控制,如果您读过之前的文章,您会发现,关于锁、并发控制的类的实现全部是基于AQS的,所以理解透彻AQS的实现,对于理解这些工具类是至关重要的,如果您对于AQS的实现有不清楚的地方,建议您看一下之前的文章,对于AQS的分析,以及几篇关于锁的文章的介绍,希望可以帮助您更加深入理解并发工具类。
聊聊并发:(七)concurrent包之AbstractQueuedSynchronizer分析
从下篇开始,我们开始介绍并发容器的工具类的实现,敬请期待!
更多Java干货文章请关注我的个人微信公众号:老宣与你聊Java