Semaphore使用及原理解读

Love The Way You Lie 2023-10-13 04:57 47阅读 0赞

#### 使用 ####

##### 概述 #####

Semaphore（信号量）是Java中一个并发控制工具，用于控制对共享资源的访问。它基于计数器的原理，可以限制同时访问某个资源的线程数量。

在Java中使用Semaphore，你需要按照以下步骤进行操作：

导包：

import java.util.concurrent.Semaphore;

创建Semaphore对象：

Semaphore semaphore = new Semaphore(n);

其中，`n`是允许同时访问共享资源的线程数量。

在需要访问共享资源的代码段前后，使用acquire()和release()方法来获取和释放信号量：

try {
        semaphore.acquire(); // 获取信号量，如果没有可用的许可证，线程将被阻塞
        // 访问共享资源的代码
    } catch (InterruptedException e) {
        // 处理中断异常
    } finally {
        semaphore.release(); // 释放信号量，增加一个许可证
    }

`acquire()`方法尝试获取一个许可证，如果当前没有可用的许可证，则该线程将被阻塞，直到有可用的许可证为止。`release()`方法释放一个许可证，使其可供其他线程使用。

通过适当地使用`acquire()`和`release()`方法，在超过信号量允许的线程数量时，可以限制并发访问共享资源的线程数量，实现线程间的同步和互斥。

需要注意的是，Semaphore还提供了一些其他方法，如availablePermits()用于获取当前可用的许可证数量，以及tryAcquire()方法在不阻塞线程的情况下尝试获取许可证等。

##### 具体例子 #####

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

> 07:35:15.485 c.TestSemaphore \[Thread-2\] - running...
> 
> 07:35:15.485 c.TestSemaphore \[Thread-1\] - running...
> 
> 07:35:15.485 c.TestSemaphore \[Thread-0\] - running...
> 
> 07:35:16.490 c.TestSemaphore \[Thread-2\] - end...
> 
> 07:35:16.490 c.TestSemaphore \[Thread-0\] - end...
> 
> 07:35:16.490 c.TestSemaphore \[Thread-1\] - end...
> 
> 07:35:16.490 c.TestSemaphore \[Thread-3\] - running...
> 
> 07:35:16.490 c.TestSemaphore \[Thread-5\] - running...
> 
> 07:35:16.490 c.TestSemaphore \[Thread-4\] - running...
> 
> 07:35:17.490 c.TestSemaphore \[Thread-5\] - end...
> 
> 07:35:17.490 c.TestSemaphore \[Thread-4\] - end...
> 
> 07:35:17.490 c.TestSemaphore \[Thread-3\] - end...
> 
> 07:35:17.490 c.TestSemaphore \[Thread-6\] - running...
> 
> 07:35:17.490 c.TestSemaphore \[Thread-7\] - running...
> 
> 07:35:17.490 c.TestSemaphore \[Thread-9\] - running...
> 
> 07:35:18.491 c.TestSemaphore \[Thread-6\] - end...
> 
> 07:35:18.491 c.TestSemaphore \[Thread-7\] - end...
> 
> 07:35:18.491 c.TestSemaphore \[Thread-9\] - end...
> 
> 07:35:18.491 c.TestSemaphore \[Thread-8\] - running...
> 
> 07:35:19.492 c.TestSemaphore \[Thread-8\] - end...

#### 源码原理解析 ####

##### 加锁解锁流程原理 #####

Semaphore 有点像一个停车场，permits 就好像停车位数量，当线程获得了 permits 就像是获得了停车位，然后 停车场显示空余车位减一 刚开始，permits（state）为 3，这时 5 个线程来获取资源

![06e9a33eeeb0486a88c03c76e87d3073.png][]

假设其中 Thread-1，Thread-2，Thread-4 cas 竞争成功，而 Thread-0 和 Thread-3 竞争失败，进入 AQS 队列park 阻塞

![feb5875f58c6484ba2c4d51598d01ffb.png][]

接下来 Thread-0 竞争成功，permits 再次设置为 0，设置自己为 head 节点，断开原来的 head 节点，unpark 接 下来的 Thread-3 节点，但由于 permits 是 0，因此 Thread-3 在尝试不成功后再次进入 park 状态

![d931c851070948acacd9418d3a1c4798.png][]

##### 源码 #####

构造方法有俩个：

public Semaphore(int permits) {
            sync = new NonfairSync(permits);
        }

> 创建 Semaphore 具有给定数量的许可和不公平公平设置。  
> 参数：  
> 许可证 – 可用的许可证的初始数量。此值可能为负数，在这种情况下，必须先进行释放，然后才能授予任何收购。

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

> 创建具有给定数量的许可和给定公平性设置的 。Semaphore  
> 参数：  
> 许可证 – 可用的许可证的初始数量。此值可能为负数，在这种情况下，必须先进行释放，然后才能授予任何收购。  
> 公平 – true 如果此信号量将保证在争用中授予先进先出的许可证，否则 false

static final class NonfairSync extends Sync {
            private static final long serialVersionUID = -2694183684443567898L;
    
            NonfairSync(int permits) {
                // permits 即 state
    
                super(permits);
            }
    
            // Semaphore 方法, 方便阅读, 放在此处
    
            public void acquire() throws InterruptedException {
                sync.acquireSharedInterruptibly(1);
            }
    
            // AQS 继承过来的方法, 方便阅读, 放在此处
    
            public final void acquireSharedInterruptibly(int arg)
                    throws InterruptedException {
                if (Thread.interrupted())
                    throw new InterruptedException();
                if (tryAcquireShared(arg) < 0)
                    doAcquireSharedInterruptibly(arg);
            }
    
            // 尝试获得共享锁
    
            protected int tryAcquireShared(int acquires) {
                return nonfairTryAcquireShared(acquires);
            }
    
            // Sync 继承过来的方法, 方便阅读, 放在此处
    
            final int nonfairTryAcquireShared(int acquires) {
                for (;;) {
                    int available = getState();
                    int remaining = available - acquires;
                    if (
                        // 如果许可已经用完, 返回负数, 表示获取失败, 进入 doAcquireSharedInterruptibly
    
                            remaining < 0 ||
    
                                    // 如果 cas 重试成功, 返回正数, 表示获取成功
    
                                    compareAndSetState(available, remaining)
                    ) {
                        return remaining;
                    }
                }
            }
    
            // AQS 继承过来的方法, 方便阅读, 放在此处
    
            private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
                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
    
                                // 如果 head.waitStatus == Node.SIGNAL ==> 0 成功, 下一个节点 unpark
    
                                // 如果 head.waitStatus == 0 ==> Node.PROPAGATE
    
                                // 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);
                }
            }
    
            // Semaphore 方法, 方便阅读, 放在此处
    
            public void release() {
                sync.releaseShared(1);
            }
    
            // AQS 继承过来的方法, 方便阅读, 放在此处
    
            public final boolean releaseShared(int arg) {
                if (tryReleaseShared(arg)) {
                    doReleaseShared();
                    return true;
                }
                return false;
            }
    
            // Sync 继承过来的方法, 方便阅读, 放在此处
            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;
                }
            }
        }

[06e9a33eeeb0486a88c03c76e87d3073.png]: https://img-blog.csdnimg.cn/06e9a33eeeb0486a88c03c76e87d3073.png
[feb5875f58c6484ba2c4d51598d01ffb.png]: https://img-blog.csdnimg.cn/feb5875f58c6484ba2c4d51598d01ffb.png
[d931c851070948acacd9418d3a1c4798.png]: https://img-blog.csdnimg.cn/d931c851070948acacd9418d3a1c4798.png