信号量Semaphore详解

深藏阁楼爱情的钟 2023-09-23 17:06 133阅读 0赞

## 前言 ##

大家应该都用过`synchronized` 关键字加锁，用来保证某个时刻只允许一个线程运行。那么如果控制某个时刻允许指定数量的线程执行，有什么好的办法呢? 答案就是JUC提供的信号量`Semaphore`。

## 介绍和使用 ##

*  `Semaphore`（信号量）可以用来限制能同时访问共享资源的线程上限，它内部维护了一个**许可**的变量，也就是线程许可的数量
 *  `Semaphore`的许可数量如果小于0个，就会阻塞获取，直到有线程释放许可
 *  `Semaphore`是一个非重入锁

### API介绍 ###

1.  **构造方法**

*  `public Semaphore(int permits)`：`permits` 表示许可线程的数量
 *  `public Semaphore(int permits, boolean fair)`：`fair` 表示公平性，如果设为 `true`，表示是公平，那么等待最久的线程先执行

1.  **常用API**

*  `public void acquire()`：表示一个线程获取1个许可，那么线程许可数量相应减少一个
 *  `public void release()`：表示释放1个许可，那么线程许可数量相应会增加

1.  **其他API**

*  `void acquire(int permits)`：表示一个线程获取n个许可，这个数量由参数`permits`决定
 *  `void release(int permits)`：表示一个线程释放n个许可，这个数量由参数`permits`决定
 *  `int availablePermits()`：返回当前信号量线程许可数量
 *  `int getQueueLength()`: 返回等待获取许可的线程数的预估值

### 基本使用 ###

public static void main(String[] args) {
            // 1. 创建 semaphore 对象
            Semaphore semaphore = new Semaphore(2);
            // 2. 10个线程同时运行
            for (int i = 0; i < 8; i++) {
                new Thread(() -> {
                    // 3. 获取许可
                    try {
                        semaphore.acquire();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    try {
                        log.debug("running...");
                        sleep(1);
                        log.debug("end...");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        // 4. 释放许可
                        semaphore.release();
                    }
                }).start();
            }
        }
    复制代码

**运行结果：**

![format_png][]

## 原理介绍 ##

![format_png 1][]

上面是`Semaphore`的类结构图，其中`FairSync`和`NonfairSync`是它的内部类，他们共同继承了AQS类，AQS的共享模式提供了`Semaphore`的加锁、解锁。

为了更好的搞懂原理，我们通过一个例子来帮助我们理解。

假设`Semaphore` 的 `permits`为 3，这时 5 个线程来获取资源，其中`Thread-1`，`Thread-2`，`Thread-4`CAS 竞争成功，`permits` 变为 0，而`Thread-0`和 `Thread-3` 竞争失败。

![format_png 2][]

### 获取许可acquire() ###

*  `acquire()`主方法会调用 `sync.acquireSharedInterruptibly(1)`方法
 *  `acquireSharedInterruptibly()`方法会先调用`tryAcquireShared()`方法返回许可的数量，如果小于0个，调用`doAcquireSharedInterruptibly()`方法进入阻塞

// acquire() -> sync.acquireSharedInterruptibly(1)，可中断
    public final void acquireSharedInterruptibly(int arg) {
        if (Thread.interrupted())
            throw new InterruptedException();
        // 尝试获取通行证，获取成功返回 >= 0的值
        if (tryAcquireShared(arg) < 0)
            // 获取许可证失败，进入阻塞
            doAcquireSharedInterruptibly(arg);
    }
    复制代码

*  `tryAcquireShared()`方法在终会调用到`Sync#nonfairTryAcquireShared()`方法
 *  `nonfairTryAcquireShared()`方法中会减去获取的许可数量，返回**剩余**的许可数量

// tryAcquireShared() -> nonfairTryAcquireShared()
    // 非公平，公平锁会在循环内 hasQueuedPredecessors()方法判断阻塞队列是否有临头节点(第二个节点)
    final int nonfairTryAcquireShared(int acquires) {
        for (;;) {
            // 获取 state ，state 这里【表示通行证】
            int available = getState();
            // 计算当前线程获取通行证完成之后，通行证还剩余数量
            int remaining = available - acquires;
            // 如果许可已经用完, 返回负数, 表示获取失败,
            if (remaining < 0 ||
                // 许可证足够分配的，如果 cas 重试成功, 返回正数, 表示获取成功
                compareAndSetState(available, remaining))
                return remaining;
        }
    }
    复制代码

*  如果剩余的许可数量<0， 会调用`doAcquireSharedInterruptibly()`方法将当前线程加入到阻塞队列中阻塞
 *  方法中调用`parkAndCheckInterrupt()`阻塞当前线程

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);
        }
    }
    复制代码

最终的AQS状态如下图所示：

*  `Thread-1`、`Thread-2`、`Thread-4`正常运行
 *  AQS的`state`也就是等于0
 *  `Thread-0`、`Thread-3`再阻塞队列中

![format_png 3][]

### 释放许可release() ###

现在`Thread-4`运行完毕，要释放许可，`Thread-0`、`Thread-3`又是如何恢复执行的呢？

*  调用`release()`方法释放许可，最终调用 `Sync#releaseShared()`方法
 *  如果方法`tryReleaseShared(arg)`尝试释放许可成功，那么调用`doReleaseShared();`进行唤醒

// release() -> releaseShared()
    public final boolean releaseShared(int arg) {
        // 尝试释放锁
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }    
        return false;
    }
    复制代码

*  `tryReleaseShared()`方法主要是尝试释放许可
 *  获取当前许可数量 + 释放的数量，然后通过cas设置回去

protected final boolean tryReleaseShared(int releases) {    
        for (;;) {
            // 获取当前锁资源的可用许可证数量
            int current = getState();
            int next = current + releases;
            // 索引越界判断
            if (next < current)            
                throw new Error("Maximum permit count exceeded");        
            // 释放锁
            if (compareAndSetState(current, next))            
                return true;    
        }
    }
    复制代码

*  调用`doReleaseShared()`方法唤醒队列中的线程
 *  其中`unparkSuccessor()`方法是唤醒的核心操作

// 唤醒
    private void doReleaseShared() {
        // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一个节点 unpark	
        // 如果 head.waitStatus == 0 ==> Node.PROPAGATE    
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    // 防止 unparkSuccessor 被多次执行
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;
                    // 唤醒后继节点
                    unparkSuccessor(h);
                }
                // 如果已经是 0 了，改为 -3，用来解决传播性
                else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;
            }
            if (h == head)
                break;
        }
    }
    复制代码

最终AQS状态如下图所示：

![format_png 4][]

*  许可state变回1
 *  然后`Thread-0`开始竞争，如果竞争成功，如下图所示：

![format_png 5][]

*  由于Thread-0竞争成功，再次获取到许可，许可数量减1，最终又变回0
 *  然后等待队列中剩余`Thread-3`

## 总结 ##

`Semaphore`信号量类基于AQS的共享锁实现，有公平锁和非公平锁两个版本，它用来限制能同时访问共享资源的线程上限，典型的应用场景是可以用来保护有限的公共资源，比如数据库连接等。

[format_png]: https://img-blog.csdnimg.cn/img_convert/c7821654c11e4ba5c236ae2b8cb56ecf.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/941c2bc09f20c7fca33fd71d8fc97897.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/cbfd1a2410537634fa7fc652548f47c5.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/20fc1d36cca6d85055d5ca56cc576704.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/dfda6fccac4be5ea77a7231380f6880f.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/d8d6b148881e49b8733be013d1ef09e0.webp?x-oss-process=image/format,png