Semaphore 信号量

throw new InterruptedException();

doAcquireSharedInterruptibly(arg);

next

sync.releaseShared(1);

Semaphore

        Node s = node.next;        if (s == null || s.waitStatus > 0) {            s = null;            for (Node t = tail; t != null && t != node; t = t.prev)                if (t.waitStatus <= 0)                    s = t;        }

结束

是

failed == true

共享模式 AQS 队列结构

出队

释放锁（释放信号量）

唤醒节点

 LockSupport.unpark(s.thread);

prev

唤醒等待节点

for 循环

true

unparkSuccessor(h);

thread

入队

通过 CAS 方式执行state +1 释放资源

nonfairTryAcquireShared(acquires)

尝试获取如果失败进入中断

Semaphore#release()

清除等待状态

tryReleaseShared(arg)

AbstractQueuedSynchronizer

nextWaiter

进入阻塞失败

2.2

doReleaseShared();

线程激活

tryAcquireShared(arg)

r >= 0

独木桥

AbstractQueuedSynchronizer 的 state 来存储信号量的剩余情况，通过 CAS 方式进行消费，返回结果

找到有效的唤醒节点，可能在队列中的一些线程已经取消状态不符合等情况

否

文本

2.1

final Node node = addWaiter(Node.SHARED);

int r = tryAcquireShared(arg);

acquireSharedInterruptibly

doReleaseShared()

p == head

parkAndCheckInterrupt() 

h != null && h != tail

如果 AQS 队列中存在非空节点

成功

默认非公平

ws == Node.SIGNAL

桥上只能承受 5 个人

尝试获取共享锁

释放共享锁

tryAcquireShared(arg) < 0

继续循环

 cancelAcquire(node);

h == head

Semaphore#acquire()

线程阻塞

false

获取锁

1.1

final Node p = node.predecessor();

如果是头节点

failed = false;