限流器:让一组线程只能同时让固定数量的线程同时执行。各种同步器其实都是基于AQS实现的。其中最重要的是 state 和里面的同步等待队列,说明就是一个链表
Semaphore semp = new Semaphore(5);
也可以声明为公平的同步构造器
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
NonfairSync(int permits) {
super(permits);
}
Sync(int permits) {
setState(permits);
}
此致,构造方法其实就是申明了 state 的值,我先告诉大家大概原理,再来追踪源码,所有线程都会尝试通过 CAS的方式对state值减一操作,如果操作成功并且 state 的值大于0 ,则获得执行权限,可以执行,否则放入同步队列,并且进入阻塞。
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)//这个方法尝试对state减一并且返回state 后的值,如果返回后的值小于0,则调用下面的方法
doAcquireSharedInterruptibly(arg);
}
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))
//很简单的逻辑判断,参数 acquires==1,如果减一之后小于0,或者CAS减一操作成功,则直接返回,可以直接往下 执行,没有任何阻塞操作。
return remaining;
}
}
接着看 doAcquireSharedInterruptibly(arg);不用看都能猜到是会进行一下阻塞操作
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED); 添加一个节点,并且设置到队列尾部
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
先来看看这个addWaiter 方法,这个方法从名字上看就是添加一个等待节点。
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail; 申明一个节点变量指向 tail 尾部节点。
if (pred != null) { 如果尾部节点不为空,
node.prev = pred; 则设置当前新建的节点的前一个节点为尾部节点
if (compareAndSetTail(pred, node)) { 用 CAS方式 设置当前节点为尾部节点
pred.next = node;
return node;
}
}
enq(node); 这个方法的意思就是吧当前节点弄到等待队列的尾部去。这里还没看见让线程停止运行的痕迹,还要往下看
return node;
}
看下这个 enq(node);
private Node enq(final Node node) {
for (;;) { 自旋,不断尝试
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node())) 这里判断头节点是否为null,为null则设置为头部,其实就是判断这个等待队列 里面有没有人,没有人就放着最前面的意思,接下来这行代码也是这个意思
tail = head;
} else {
node.prev = t; 如果这个队列已经有等待的其他节点了,就放到接下来下一个位置,当前节点的前一个节点等于尾部节点
if (compareAndSetTail(t, node)) { 判断内存中tail字段的值是否发生了改变,如果没有则设置node节点为尾部节点, 并且返回,结束死循环
t.next = node;
return t;
}
}
}
}
接着看刚才那个方法
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED); 前面分析结果就是让等待队列中添加一个节点
boolean failed = true;
try {
for (;;) { 又自旋,
final Node p = node.predecessor(); 我们来看看这个是啥意思 AQS 里面有个属性volatile Node prev; 这个方法没多大意思,就是node =prev 这个逻辑而已。
if (p == head) {
int r = tryAcquireShared(arg); 这个唯一逻辑就是 return (getState() == 0) ? 1 : -1;
if (r >= 0) { 等同getState() == 0 ,就是可以接着执行,不用阻塞啦。
setHeadAndPropagate(node, r); 大概意思就是唤醒当前线程 。核心 LockSupport.unpark(s.thread);
这里多说两句,LockSupport.park() 消费运行许可证,一次性消费完,就算生产再多,调用两次park()将进入阻塞 状态,unpark 是生产许可证。
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// parkAndCheckInterrupt() 方法的唯一逻辑 : LockSupport.park(this);return Thread.interrupted();很明显是让线程停止运行
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
在来看看线程执行完了要调用
public void release() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) { //对state 加一操作,就是上厕所来比喻,本来一个厕所五个位置,一个人出来后,剩余位置就多了一个,state其实维护的是剩余的位置数量
doReleaseShared();//核心逻辑就是对阻塞队列头部的线程进行LockSupport.unpark()生产运行许可证,可以理解为唤醒操作
return true;
}
return false;
}
总结一下: 所有线程开始的时候都试图对state值进行CAS减一操作,是占位置,如果占位置成功,则对state减一,否则包装一个node节点,放到等待队列尾部去,并且调用LockSupport.park()方法进行阻塞操作。拥有运行权限的线程执行完后,会释放位置,对state进行加一操作。并且唤醒等待队列中头部的线程。