文章目录
前言
如果只是了解使用，往下看即可
如果想了解原理，需要具备AQS、lock锁的实现原理才方便理解。
一篇文章彻底搞懂AQS（独占锁）、ReentrantLock“加锁”分析上（源码级别，深度剖析）（传送门）
一篇文章彻底搞懂AQS（独占锁）、ReentrantLock“解锁”分析下（源码级别，深度剖析）（传送门）
一、Semaphore是什么？
Semaphore 字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目，底层依赖AQS的状态State，是在生产当中比较常用的一个工具类。
1、构造方法
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
permits ：表示许可线程的数量
fair ：表示公平性，如果这个设为 true 的话，下次执行的线程会是等待最久的线程
2、属性
private final Sync sync;
维护一个sync属性，和lock一样也有FairSync和NonfairSync的实现
3、常用方法
public void acquire() throws InterruptedException
public boolean tryAcquire()
public void release()
public int availablePermits()
public final int getQueueLength()
public final boolean hasQueuedThreads()
protected void reducePermits(int reduction)
acquire() ：表示阻塞并获取许可
tryAcquire() ：方法在没有许可的情况下会立即返回 false，要获取许可的线程不会阻塞
release() ：表示释放许可
int availablePermits()：返回此信号量中当前可用的许可证数。
int getQueueLength()：返回正在等待获取许可证的线程数。
boolean hasQueuedThreads()：是否有线程正在等待获取许可证。
void reducePermit（int reduction）：减少 reduction 个许可证
Collection getQueuedThreads()：返回所有等待获取许可证的线程集合
4、使用场景
可以用于做流量控制，特别是公用资源有限的应用场景。服务限流(Hystrix里限流就有基于信号量方式)。
买票代码案例：
public class SemaphoreRunner {
public static void main(String[] args) {
// 声明3个窗口 state: 资源数
Semaphore windows = new Semaphore(3);
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
// 占用窗口 加锁
windows.acquire();
System.out.println(Thread.currentThread().getName() + ": 开始买票");
//模拟买票流程
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + ": 购票成功");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放窗口
windows.release();
}
}
}).start();
}
}
}
打印结果：
可以看到同一时刻只有3个线程在运行。
Thread-0: 开始买票
Thread-1: 开始买票
Thread-3: 开始买票
Thread-1: 购票成功
Thread-0: 购票成功
Thread-3: 购票成功
Thread-4: 开始买票
Thread-2: 开始买票
Thread-2: 购票成功
Thread-4: 购票成功
5、大概原理实现
获取资源操作
1、每个线程进来，信号量-1
2、要是信号量还是大于等于0，则线程继续执行
3、要是信号量小于0，则线程被被阻塞后进入同步队列等待，等着被唤醒，继续尝试信号量
释放资源操作
1、信号量+1
2、如果信号量大于0，则线程继续执行
3、如相加后还是小于等于0，则继续等待队。
二、核心源码分析
2.1、tryAcquireShared -共享加锁的源码解析
// 加锁
windows.acquire();
以上面代码代入源码：
tryAcquireShared 有公平、非公平的实现
主要区别是，如果是公平锁，则排队。
下面代码以非公平调用顺序，
这里重点需要关注的是tryAcquireShared里面的nonfairTryAcquireShared（非公平尝试获取共享锁）方法实现。
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);
}
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
final int nonfairTryAcquireShared(int acquires) {
// 1、自旋
for (;;) {
// 2、获取信号量
int available = getState();
// 3、信号量-1,CAS更新信号量，CAS成功则共享锁加锁成功返回
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}
与lock独占锁逻辑不同的地方就是加锁。
tryAcquireShared方法做了几件事情：
如果nonfairTryAcquireShared方法返回结果<0,表示没有信号量了。
调用doAcquireSharedInterruptibly方法进行入队阻塞处理。
nonfairTryAcquireShared方法主要做了几件事情
1、自旋
2、获取信号量
3、信号量-1,CAS更新信号量，CAS成功则共享锁加锁成功返回
2.2、doAcquireSharedInterruptibly-共享队列进队阻塞
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
// 1、创建共享节点
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
// 2、如果当前节点的上一节点是头部节点还会再抢一次锁
if (p == head) {
int r = tryAcquireShared(arg);
// 3、这里重点关注，和独占锁不同的地方，这里如果抢锁成功，信号量大于0，表示还有信号量，会继续尝试唤醒下一节点
if (r >= 0) {
// 设置头部节点并且往后传播
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
// 4、设置上一节点为-1(表示可以唤醒) 并且阻塞当前节点线程
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
方法主要做了几件事情
1、创建共享节点
2、如果当前节点的上一节点是头部节点还会再抢一次锁
3、这里重点关注，和独占锁不同的地方，这里如果抢锁成功，信号量大于0，表示还有信号量，会继续尝试唤醒下一节点
4、设置上一节点为-1(表示可以唤醒) 并且阻塞当前节点线程
2.3、release-释放锁源码解析
以这个代码切入源码分析
// 释放锁
windows.release();
public void release() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
/// 1、更新信号量
if (tryReleaseShared(arg)) {
// 2、释放资源、并唤醒阻塞的头部节点
doReleaseShared();
return true;
}
return false;
}
protected final boolean tryReleaseShared(int releases) {
for (;;) {
// 自旋+cas更新信号量
int current = getState();
int next = current + releases;
if (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
private void doReleaseShared() {
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
主要做了几件事情
1、**tryReleaseShared方法：**自旋+cas更新信号量，更新成功
2、**doReleaseShared方法：**释放资源，并且唤醒头节点的下一节点
三、模拟5个线程加锁、解锁过程
以这个买票案例来解析
public class SemaphoreRunner {
public static void main(String[] args) {
// 声明3个窗口 state: 资源数
Semaphore windows = new Semaphore(3);
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
try {
// 占用窗口 加锁
windows.acquire();
System.out.println(Thread.currentThread().getName() + ": 开始买票");
//模拟买票流程
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + ": 购票成功");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放窗口
windows.release();
}
}
}).start();
}
}
}
3.1、线程0 、1、2加锁逻辑
信号量为3，所以线程0、1、2进来就可以直接获取执行线程成功，初始化队列。
3.2、线程3加锁逻辑
线程3进来，由于信号量已经为0，所以需要入队，阻塞，队尾指针指向新创建的节点，在把头节点置为-1，表示阻塞，下一节点可唤醒
3.4、线程4加锁逻辑
由于线程0、1、2线程还没释放，所以线程4进来和线程3执行逻辑一致，
区别是因为线程4，加在队尾， 线程3是线程4的上一节点，所以线程3状态也要置为-1。
3.5、线程0释放资源逻辑
释放线程0的资源，唤醒阻塞的线程3.头部节点
线程3唤醒后，尝试获取资源成功，移除头部节点出队列，并且头部队列状态改为-1.
如果是共享模式，则会尝试唤醒下一节点。
484
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
