Java并发编程之Semaphore信号量

Semaphore:

1. Semaphore基于AQS的共享模式实现，主要用于在总体许可（permits）一定的情况下，限制线程的并发访问，可用于实现：服务限流。

2. 获取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可以获取成功。