Semaphore.acquire()方法的底层原理

一、acquire() 的工作流程

当调用 acquire() 方法时，实际调用的是 AQS 的 acquireSharedInterruptibly(1) 方法。以下是其详细工作流程：

   // acquire() -> sync.acquireSharedInterruptibly(1)，可中断
   public final void acquireSharedInterruptibly(int arg) {

        if (Thread.interrupted())
            throw new InterruptedException();

        // 尝试获取通行证，获取成功返回 >= 0的值
        if (tryAcquireShared(arg) < 0)
            // 获取许可证失败，进入阻塞
            doAcquireSharedInterruptibly(arg);
    }

1、Semaphore.acquire()

  public void acquire() throws InterruptedException {

        sync.acquireSharedInterruptibly(1); // 调用 AQS 的共享模式方法
  }

2、AQS.acquireSharedInterruptibly(int arg)

  public final void acquireSharedInterruptibly(int arg) throws InterruptedException {

        if (Thread.interrupted()) {
            throw new InterruptedException(); // 检查中断状态
        }

        if (tryAcquireShared(arg) < 0) { // 尝试获取许可
            doAcquireSharedInterruptibly(arg); // 许可不足，加入队列
        }
  }

3、Semaphore.tryAcquireShared(int acquires)

  protected int tryAcquireShared(int acquires) {
        for (;;) {
            int available = getState(); // 当前剩余许可数
            int remaining = available - acquires; // 计算剩余许可
            if (remaining < 0 || compareAndSetState(available, remaining)) {
                return remaining; // 返回负数表示需要排队，非负数表示成功，需要通过 CAS 更新 state 变量（将available更新remaining）
            }
        }
  }

4、doAcquireSharedInterruptibly(int arg)，许可不足，加入队列

   private void doAcquireSharedInterruptibly(int arg) {
          // 将调用 Semaphore.aquire 方法的线程，包装成 node 加入到 AQS 的阻塞队列中
          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) {
                          // 成功后本线程出队（AQS）, 所在 Node设置为 head
                          // r 表示【可用资源数】, 为 0 则不会继续传播
                          setHeadAndPropagate(node, r); 
                          p.next = null; // help GC
                          failed = false;
                          return;
                      }
                  }
                  // 不成功, 设置上一个节点 waitStatus = Node.SIGNAL, 下轮进入 park 阻塞
                  if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                      throw new InterruptedException();
              }
          } finally {
              // 被打断后进入该逻辑
              if (failed)
                  cancelAcquire(node);
          }
   }

5、setHeadAndPropagate(Node node, int propagate)

  private void setHeadAndPropagate(Node node, int propagate) {  
  
        Node h = head;

        // 设置自己为 head 节点
        setHead(node);

        // propagate 表示有【共享资源】（例如共享读锁或信号量）
        // head waitStatus == Node.SIGNAL 或 Node.PROPAGATE，doReleaseShared 函数中设置的
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            // 如果是最后一个节点或者是等待共享读锁的节点，做一次唤醒
            if (s == null || s.isShared())
                doReleaseShared();
        }
  }

二、acquire() 的工作流程

当调用 acquire() 方法时，实际调用的是 AQS 的 acquireSharedInterruptibly(1) 方法。以下是其详细工作流程：

(1) 尝试获取许可

A、调用 tryAcquireShared(arg)：

• tryAcquireShared(arg) 是 AQS 的模板方法，由 Semaphore 实现

• 在 Semaphore 中，tryAcquireShared(arg) 的逻辑是检查当前剩余许可数 state 是否足够

  • 如果 state >= 1，通过 int remaining = available - acquires; 操作将 state 减 1。

  • 如果 state < 1，返回负数，表示许可不足。

B、CAS 操作：

• 使用 compareAndSetState(available, remaining) 方法原子性地更新 state 变量。

• 如果 CAS 成功，表示线程成功获取许可；否则，重试或进入排队逻辑。

(2) 加入等待队列

A、创建节点并加入队列：

• 如果 tryAcquireShared(arg) 返回负数（许可不足），线程会被封装为一个 Node 对象，加入 AQS 的 CLH 队列 尾部。

• CLH 队列是一个双向链表，用于管理等待线程。

B、自旋与阻塞：

• 线程在队列中自旋，尝试再次获取许可。

• 如果仍然无法获取许可，线程通过 LockSupport.park() 方法被挂起，进入阻塞状态。