计算机选什么专业最好,seo引擎优化公司,轻食网络推广方案,wordpress 做影视站使用
Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞#xff0c;直到有一个许可证可以获得然后拿走一个许可证#xff1b;每个release方法增加一个许可证#xff0c;这可能会释放一个阻塞的acquire方法。然而#xff0c;其实并没有实际的许可证这…使用
Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞直到有一个许可证可以获得然后拿走一个许可证每个release方法增加一个许可证这可能会释放一个阻塞的acquire方法。然而其实并没有实际的许可证这个对象Semaphore只是维持了一个可获得许可证的数量。 Semaphore经常用于限制获取某种资源的线程数量。下面举个例子比如说操场上有5个跑道一个跑道一次只能有一个学生在上面跑步一旦所有跑道在使用那么后面的学生就需要等待直到有一个学生不跑了下面是这个例子
/*** 操场有5个跑道* Created by Xingfeng on 2016-12-09.*/
public class Playground {/*** 跑道类*/static class Track {private int num;public Track(int num) {this.num num;}Overridepublic String toString() {return Track{ num num };}}private Track[] tracks {new Track(1), new Track(2), new Track(3), new Track(4), new Track(5)};private volatile boolean[] used new boolean[5];private Semaphore semaphore new Semaphore(5, true);/*** 获取一个跑道*/public Track getTrack() throws InterruptedException {semaphore.acquire(1);return getNextAvailableTrack();}/*** 返回一个跑道** param track*/public void releaseTrack(Track track) {if (makeAsUsed(track))semaphore.release(1);}/*** 遍历找到一个没人用的跑道** return*/private Track getNextAvailableTrack() {for (int i 0; i used.length; i) {if (!used[i]) {used[i] true;return tracks[i];}}return null;}/*** 返回一个跑道** param track*/private boolean makeAsUsed(Track track) {for (int i 0; i used.length; i) {if (tracks[i] track) {if (used[i]) {used[i] false;return true;} else {return false;}}}return false;}}
从上面可以看到创建了5个跑道对象并使用一个boolean类型的数组记录每个跑道是否被使用了初始化了5个许可证的Semaphore在获取跑道时首先调用acquire(1)获取一个许可证在归还一个跑道是调用release(1)释放一个许可证。接下来再看启动程序如下
public class SemaphoreDemo {static class Student implements Runnable {private int num;private Playground playground;public Student(int num, Playground playground) {this.num num;this.playground playground;}Overridepublic void run() {try {//获取跑道Playground.Track track playground.getTrack();if (track ! null) {System.out.println(学生 num 在 track.toString() 上跑步);TimeUnit.SECONDS.sleep(2);System.out.println(学生 num 释放 track.toString());//释放跑道playground.releaseTrack(track);}} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {Executor executor Executors.newCachedThreadPool();Playground playground new Playground();for (int i 0; i 100; i) {executor.execute(new Student(i1,playground));}}}
上面的代码中Student类代表学生首先获取跑道一旦获取到就打印一句话然后睡眠2s然后再打印释放最后归还跑道。
源码解析
Semaphore有两种模式公平模式和非公平模式。公平模式就是调用acquire的顺序就是获取许可证的顺序遵循FIFO而非公平模式是抢占式的也就是有可能一个新的获取线程恰好在一个许可证释放时得到了这个许可证而前面还有等待的线程。
构造方法
Semaphore有两个构造方法如下public Semaphore(int permits) {sync new NonfairSync(permits);}public Semaphore(int permits, boolean fair) {sync fair ? new FairSync(permits) : new NonfairSync(permits);}
从上面可以看到两个构造方法都必须提供许可的数量第二个构造方法可以指定是公平模式还是非公平模式默认非公平模式。
Semaphore内部基于AQS的共享模式所以实现都委托给了Sync类。 这里就看一下NonfairSync的构造方法NonfairSync(int permits) {super(permits);}
可以看到直接调用了父类的构造方法Sync的构造方法如下
Sync(int permits) {setState(permits);}
可以看到调用了setState方法也就是说AQS中的资源就是许可证的数量。
获取许可
先从获取一个许可看起并且先看非公平模式下的实现。首先看acquire方法acquire方法有几个重载但主要是下面这个方法
public void acquire(int permits) throws InterruptedException {if (permits 0) throw new IllegalArgumentException();sync.acquireSharedInterruptibly(permits);}
从上面可以看到调用了Sync的acquireSharedInterruptibly方法该方法在父类AQS中如下
public final void acquireSharedInterruptibly(int arg)throws InterruptedException {//如果线程被中断了抛出异常if (Thread.interrupted())throw new InterruptedException();//获取许可失败将线程加入到等待队列中if (tryAcquireShared(arg) 0)doAcquireSharedInterruptibly(arg);}
AQS子类如果要使用共享模式的话需要实现tryAcquireShared方法下面看NonfairSync的该方法实现protected int tryAcquireShared(int acquires) {return nonfairTryAcquireShared(acquires);}
该方法调用了父类中的nonfairTyAcquireShared方法如下
final int nonfairTryAcquireShared(int acquires) {for (;;) {//获取剩余许可数量int available getState();//计算给完这次许可数量后的个数int remaining available - acquires;//如果许可不够或者可以将许可数量重置的话返回if (remaining 0 ||compareAndSetState(available, remaining))return remaining;}}
从上面可以看到只有在许可不够时返回值才会小于0其余返回的都是剩余许可数量这也就解释了一旦许可不够后面的线程将会阻塞。看完了非公平的获取再看下公平的获取代码如下protected int tryAcquireShared(int acquires) {for (;;) {//如果前面有线程再等待直接返回-1if (hasQueuedPredecessors())return -1;//后面与非公平一样int available getState();int remaining available - acquires;if (remaining 0 ||compareAndSetState(available, remaining))return remaining;}}
从上面可以看到FairSync与NonFairSync的区别就在于会首先判断当前队列中有没有线程在等待如果有就老老实实进入到等待队列而不像NonfairSync一样首先试一把说不定就恰好获得了一个许可这样就可以插队了。
看完了获取许可后再看一下释放许可。
释放许可
释放许可也有几个重载方法但都会调用下面这个带参数的方法
public void release(int permits) {if (permits 0) throw new IllegalArgumentException();sync.releaseShared(permits);}
releaseShared方法在AQS中如下
public final boolean releaseShared(int arg) {//如果改变许可数量成功if (tryReleaseShared(arg)) {doReleaseShared();return true;}return false;}
AQS子类实现共享模式的类需要实现tryReleaseShared类来判断是否释放成功实现如下
protected final boolean tryReleaseShared(int releases) {for (;;) {//获取当前许可数量int current getState();//计算回收后的数量int next current releases;if (next current) // overflowthrow new Error(Maximum permit count exceeded);//CAS改变许可数量成功返回trueif (compareAndSetState(current, next))return true;}}
从上面可以看到一旦CAS改变许可数量成功那么就会调用doReleaseShared()方法释放阻塞的线程。
减小许可数量
Semaphore还有减小许可数量的方法该方法可以用于用于当资源用完不能再用时这时就可以减小许可证。代码如下
protected void reducePermits(int reduction) {if (reduction 0) throw new IllegalArgumentException();sync.reducePermits(reduction);}
可以看到委托给了SyncSync的reducePermits方法如下final void reducePermits(int reductions) {for (;;) {//得到当前剩余许可数量int current getState();//得到减完之后的许可数量int next current - reductions;if (next current) // underflowthrow new Error(Permit count underflow);//如果CAS改变成功if (compareAndSetState(current, next))return;}}
从上面可以看到就是CAS改变AQS中的state变量因为该变量代表许可证的数量。
获取剩余许可数量
Semaphore还可以一次将剩余的许可数量全部取走该方法是drain方法如下
public int drainPermits() {return sync.drainPermits();}
Sync的实现如下final int drainPermits() {for (;;) {int current getState();if (current 0 || compareAndSetState(current, 0))return current;}}
可以看到就是CAS将许可数量置为0。
总结
Semaphore是信号量用于管理一组资源。其内部是基于AQS的共享模式AQS的状态表示许可证的数量在许可证数量不够时线程将会被挂起而一旦有一个线程释放一个资源那么就有可能重新唤醒等待队列中的线程继续执行。
转自https://blog.csdn.net/qq_19431333/article/details/70212663
