18.详解AQS家族的成员：Semaphore

关注：王有志，一个分享硬核Java技术的互金摸鱼侠。
欢迎你加入Java人的提桶跑路群：共同富裕的Java人

今天我们来聊一聊AQS家族中另一个重要成员Semaphore，我只收集到了一道关于Semaphore的面试题，问了问“是什么”和“如何实现的”：

• 什么是Semaphore？它是如何实现的？

按照我们的惯例，依旧是按照“是什么”，“怎么用”和“如何实现的”这3步来分析Semaphore。另外，今天提供了题解。

Semaphore的使用

Semaphore直译过来是信号量，是计算机科学中非常Old School的处理同步与互斥的机制，与互斥锁不同的是它允许指定数量的线程或进程访问共享资源。

Semaphore处理同步与互斥的机制和我们平时过地铁站的闸机非常相似。刷卡打开闸机（acquire操作），通过后（访问临界区）闸机关闭（release操作），后面的人才能够继续刷卡，而在前一个人通过前，后面的人只能排队等候（队列机制）。当然，地铁站不可能只有一个闸机，拥有几个闸机，就允许几个人同时通过。

信号量也是这样的，通过构造函数定义许可数量，使用时申请许可，处理完业务逻辑后释放许可：

// 信号量中定义1个许可Semaphore semaphore = new Semaphore(1); // 申请许可semaphore.acquire(); ...... // 释放许可semaphore.release();

当我们为Semaphore定义一个许可时，它和互斥锁相同，同一时间只允许一个线程进入临界区。但是当我们定义了多个许可时，它与互斥锁的差异就体现出来了：

Semaphore semaphore = new Semaphore(3);for(int i = 1; i < 5; i++) {  int finalI = i;  new Thread(()-> {    try {      semaphore.acquire();      System.out.println("第[" + finalI + "]个线程获取到semaphore");      TimeUnit.SECONDS.sleep(10);      semaphore.release();    } catch (InterruptedException e) {      throw new RuntimeException(e);    }  }).start();}

执行这段代码可以看到，同一时间3个线程都进入了临界区，只有第4个线程被挡在了临界区外。

Semaphore的实现原理

还记得在《AQS的今生，构建出JUC的基础》中提到的同步状态吗？我们当时说它是某些同步器的计数器：

AQS中，state不仅用作表示同步状态，也是某些同步器实现的计数器，如：Semaphore中允许通过的线程数量，ReentrantLock中可重入特性的实现，都依赖于state作为计数器的特性。

先来看Semaphore与AQS的关系：

与ReentrantLock一样，Semaphore内部实现了继承自AQS的同步器抽象类Sync，并有FairSync和NonfairSync两个实现类。接下来我们就通过剖析Semaphore的源码，来验证我们之前的说法。

构造方法

Semaphore提供了两个构造方法：

public Semaphore(int permits) {  sync = new NonfairSync(permits);} public Semaphore(int permits, boolean fair) {  sync = fair ? new FairSync(permits) : new NonfairSync(permits);}

可以看到Semaphore和ReentrantLock的设计思路是一致的，Semaphore内部也实现了两个同步器FairSync和NonfairSync，分别实现公平模式和非公平模式，而Semaphore的构造本质上是构造同步器的实现。我们以非公平模式的NonfairSync的实现为例：

public class Semaphore implements java.io.Serializable {  static final class NonfairSync extends Sync {    NonfairSync(int permits) {      super(permits);    }  }    abstract static class Sync extends AbstractQueuedSynchronizer {    Sync(int permits) {      setState(permits);    }  }} public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {  protected final void setState(int newState) {    state = newState;  }}

追根溯源，构造器的参数permits最终还是回归到了AQS的state身上，借助了state作为计数器的特性来实现Semaphore的功能。

acquire方法

现在我们已经为Semaphore设置了一定数量的许可（permits），接下来我们就需要通过Semaphore#acquire方法获取许可，进入Semaphore所“守护”的临界区：

public class Semaphore implements java.io.Serializable {  public void acquire() throws InterruptedException {    sync.acquireSharedInterruptibly(1);  }} public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {  public final void acquireSharedInterruptibly(int arg) throws InterruptedException {    if (Thread.interrupted()) {      throw new InterruptedException();    }    if (tryAcquireShared(arg) < 0) {      doAcquireSharedInterruptibly(arg);    }  }}

这两步和ReentrantLock非常相似，先通过tryAcquireShared尝试直接获取许可，失败后通过doAcquireSharedInterruptibly加入到等待队列中。

Semaphore中直接获取许可的逻辑非常简单：

static final class NonfairSync extends Sync {  protected int tryAcquireShared(int acquires) {    return nonfairTryAcquireShared(acquires);  }} abstract static class Sync extends AbstractQueuedSynchronizer {  final int nonfairTryAcquireShared(int acquires) {    for (;;) {      // 获取可用许可数量      int available = getState();      // 计算许可数量      int remaining = available - acquires;      if (remaining < 0 || compareAndSetState(available, remaining)) {        return remaining;      }    }  }}

首先是获取并减少可用许可的数量，当许可数量小于0时返回一个负数，或通过CAS更新许可数量成功后，返回一个正数。此时doAcquireSharedInterruptibly会将当前的申请Semaphore许可的线程添加到AQS的等待队列中。

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {     private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {   // 创建共享模式的等待节点   final Node node = addWaiter(Node.SHARED);   try {     for (;;) {       final Node p = node.predecessor();       if (p == head) {         // 再次尝试获取许可，并返回剩余许可数量         int r = tryAcquireShared(arg);         if (r >= 0) {           // 获取成功，更新头节点           setHeadAndPropagate(node, r);           p.next = null;           return;         }       }       // 获取失败进入等待状态       if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {         throw new InterruptedException();       }     }   } catch (Throwable t) {     cancelAcquire(node);     throw t;   } }}

Semaphore的使用的doAcquireSharedInterruptibly与ReentrantLock使用的acquireQueued方法核心逻辑一直，但是有细微的实现差别：

• 创建节点使用Node.SHARED模式；

• 更新头节点使用了setHeadAndPropagate方法。

private void setHeadAndPropagate(Node node, int propagate) {  Node h = head;  setHead(node);    // 是否要唤醒等待中的节点  if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) {    Node s = node.next;    if (s == null || s.isShared()) {      // 唤醒等待中的节点      doReleaseShared();    }  }}

我们知道在ReentrantLock中执行acquireQueued，当成功获取锁后，只需要执行setHead(node)即可，那么为什么Semaphore还要再进行唤醒？

假设有3个许可的Semaphore同时有T1，T2，T3和T4总计4个线程竞争：

• 它们同时进入nonfairTryAcquireShared方法，假设只有T1通过compareAndSetState(available, remaining)成功修改有效的许可数量，T1进入临界区；

• T2，T3和T4进入doAcquireSharedInterruptibly方法，通过addWaiter(Node.SHARED)构建出AQS的等待队列（参考AQS的今生中关于addWaiter方法的分析）；

• 假设T2成为了头节点的直接后继节点，T2再次执行tryAcquireShared尝试获取许可，T3和T4执行parkAndCheckInterrupt；

• T2成功获取许可并进入临界区，此时Semaphore剩余1个许可，而T3和T4处于暂停状态中。

这种场景中，只有两个许可产生了作用，显然不符合我们对的初衷，因此在执行setHeadAndPropagate更新头节点时，判断剩余许可的数量，当数量大于0时继续唤醒后继节点。

Tips：

• Semaphore在获取许可的流程与ReentrantLock加锁的过程高度相似~~

• 下文分析doReleaseShared是如何唤醒等待中节点的。

release方法

Semaphore的release方法就非常简单了：

public class Semaphore implements java.io.Serializable {  public void release() {    sync.releaseShared(1);  }    abstract static class Sync extends AbstractQueuedSynchronizer {    protected final boolean tryReleaseShared(int releases) {      for (;;) {        int current = getState();        // 计算许可数量        int next = current + releases;        if (next < current) {          throw new Error("Maximum permit count exceeded");        }        // 通过CAS更新许可数量        if (compareAndSetState(current, next)) {            return true;        }      }    }  }} public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {  public final boolean releaseShared(int arg) {    if (tryReleaseShared(arg)) {      doReleaseShared();      return true;    }    return false;  }    private void doReleaseShared() {    for (;;) {      Node h = head;      // 判断AQS的等待队列是否为空      if (h != null && h != tail) {        int ws = h.waitStatus;        // 判断当前节点是否处于待唤醒的状态        if (ws == Node.SIGNAL) {          if (!h.compareAndSetWaitStatus(Node.SIGNAL, 0)){            continue;          }          unparkSuccessor(h);        } else if (ws == 0 && !h.compareAndSetWaitStatus(0, Node.PROPAGATE)) {          // 状态为0时，更新节点的状态为无条件传播          continue;        }      }      if (h == head) {        break;      }    }  }}

我们可以看到Semaphore的release方法分了两部分：

• tryReleaseShared方法更新Semaphore的有效许可数量；

• doReleaseShared唤醒处于等待中的节点。

唤醒的逻辑并不复杂，依旧是对节点状态waitStatus的判断，来确定是否需要执行unparkSuccessor，当状态为ws == 0，会将节点的状态更新为Node.PROPAGAT，即无条件传播。

Tips：与ReentrantLock所不同的是，Semaphore并不支持Node.CONDITION状态，同样的ReentrantLock也不支持Node.PROPAGATE状态。

结语

关于Semaphore的内容到这里就结束了，今天我们只具体分析了非公平模式下核心方法的实现，至于公平模式的实现，以及其它方法的实现，就留个大家自行探索了。

好了，希望本文能够带给你一些帮助，我们下次再见！最后欢迎大家关注王有志的专栏《Java面试都问啥？》。