Semaphore:
- Semaphore基于AQS的共享模式实现，主要用于在总体许可（permits）一定的情况下，限制线程的并发访问，可用于实现：服务限流。
- 获取permits的过程:
如上图所示，共有四个线程同时获取许可(permits)，总许可数为10。按照获取的时间顺序，Thread1获取3个许可，Thread2获取6个许可，Thread3获取3个许可，Thread4获取2个许可。显然Thread1和Thread2能够顺利获取许可并执行，但是Thread3要获取3个许可，此时Semaphore还剩下10-3-6=1个许可，因此Thread3获取失败，需要等待，此时Semaphore将Thread3放入AQS的同步队列进行等待；同理，Thread4也需要放到AQS中进行等待。
假设过了一段时间，Thread2释放（release）了6个许可，那么此时会首先唤醒AQS中的Thread3来获取许可，Thread3需要获取3个许可，而此时共有许可6+1=7个，因此Thread3获取成功继续执行；此时Thread3会同时唤醒它的后继节点Thread4，此时Thread4尝试获取2个许可，而此时共有7-3=4个许可，因此Thread4也获取成功继续执行。整体过程如下图所示：
3.具体源码:
public class Semaphore implements java.io.Serializable { private static final long serialVersionUID = -3222578661600680210L; /** All mechanics via AbstractQueuedSynchronizer subclass */ private final Sync sync; /** * Synchronization implementation for semaphore. Uses AQS state * to represent permits. Subclassed into fair and nonfair * versions. */ 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; } } } }
4.总结：通过源码可以看到Semaphore提供了2种获取许可的方式，公平和非公平模式，还是以上述的例子我们来分析一下2种模式的区别。为了能更好说明两种模式的区别，我们假设上述例子中Thread4需要获取1个许可（图中是获取2个许可）。
（1）公平模式：Thread3获取3个许可失败，需要放入AQS同步队列等待，此时Thread4需要获取1个许可（还剩下10-3-6=1）个许可，但是由于Thread3先于Thread4获取许可，因此即使Semaphore中的许可数据（1个）满足Thread4需要获取的许可数（1个），Thread4也需要等待，体现了公平性。
（2）非公平模式：Thread3获取3个许可失败，需要放入AQS同步队列等待，此时Thread4需要获取1个许可（还剩下10-3-6=1）个许可，此时Thread4可以获取成功。
