随笔系列之Semaphore

最新推荐文章于 2023-02-08 16:11:28 发布

Q蛋黄酱

最新推荐文章于 2023-02-08 16:11:28 发布

阅读量238

点赞数

分类专栏： Java多线程，关键字文章标签： Semaphore 随笔

本文链接：https://blog.csdn.net/u012961566/article/details/99413555

版权

Java多线程，关键字专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前言：

在前段时间，学习JMM以及synchronize、volatile和ReentrantLock之后，本着好奇的心思，想研究一下juc包下的其他并发控制工具，于是乎，便着手Semaphore进行研究。

一、什么是Semaphore

Semaphore，翻译过来也叫信号量，也是JUC包下一个重要的并发工具，其核心功能是为了限制并发线程数量，也可以理解为限流。

虽然说，翻译过来称之为信号量，但还是觉得叫许可管理器，更贴切一些，因为都是过来一个线程，申请一个许可，有许可就给，没许可就阻塞。线程用完许可就进行回收。

再通俗一点说，Semaphore就是synchronize 或者 ReentrantLock的衍生+升级版本的并发控制工具。

二、Semaphore的作用

而Semaphore最主要的作用还是限制并发线程数，这一点，其实可以在典型的秒杀场景里实现，比如就只有100个线程允许执行，超过一百个，就阻塞。

但这种方式，在分布式场景里，并不适用，而分布式系统往往都是在网关层面进行限流控制，这里不展开细讲。

三、Semaphore源码分析

1、 Semaphore内部结构

从上图也可以看出，其实Semaphore只实现了序列化接口，但其内部有两个类：

1）FairSync ：公平模式AQS同步器

2）NonfairSync：非公平模式AQS同步器

且这两个同步器，其父类Sync通过继承抽象类AQS（AbstractQueueSynchronizer）实现基本功能，再由上述两个子类实现公平和非公平模式的同步功能，这一点和ReentrantLock的实现方式可以说非常类似，但也有不同。不同点在于其构造函数入参以及对state的读写控制，下文将展开详细描述。

2 Semaphore关键方法

1）内部类Sync

// java.util.concurrent.Semaphore.Sync
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;
    // 构造方法，传入许可次数，放入state中
    Sync(int permits) {
        setState(permits);
    }
    // 获取许可次数
    final int getPermits() {
        return getState();
    }
    // 非公平模式尝试获取许可
    final int nonfairTryAcquireShared(int acquires) {
        // 自旋模式 获取许可
        for (;;) {
            // 看看还有几个许可
            int available = getState();
            // 减去这次需要获取的许可还剩下几个许可
            int remaining = available - acquires;
            // 如果剩余许可小于0了则直接返回
            // 如果剩余许可不小于0，则尝试原子更新state的值，成功了返回剩余许可
            if (remaining < 0 ||
                compareAndSetState(available, remaining)) // cas方式 更新剩余许可数量
                return remaining;
        }
    }
    // 释放许可
    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");
            // 如果原子更新state的值成功，就说明释放许可成功，则返回true
            if (compareAndSetState(current, next))
                return true;
        }
    }
    // 减少许可
    final void reducePermits(int reductions) {
        for (;;) {
            // 看看还有几个许可
            int current = getState();
            // 减去将要减少的许可
            int next = current - reductions;
            // 检测举出
            if (next > current) // underflow
                throw new Error("Permit count underflow");
            // 原子更新state的值，成功了返回true
            if (compareAndSetState(current, next))
                return;
        }
    }
    // 销毁许可
    final int drainPermits() {
        for (;;) {
            // 看看还有几个许可
            int current = getState();
            // 如果为0，直接返回
            // 如果不为0，把state原子更新为0
            if (current == 0 || compareAndSetState(current, 0))
                return current;
        }
    }
}

通过阅读Sync这个内部类可以看到，所谓的许可，就是一个从外部传递进来的int类型变量，Sync接受这个变量之后，并将其赋值给state，而这个过程是Semaphore在后续获取、释放许可等操作的基础前提。

而通过对Sync中提供的方法源码进行阅读可以发现，所谓的获取 or 销毁许可，就是对state变量的读写，当然这个读写必须是通过cas方式进行，来保证多线程下state的正确性。总结一下，Sync类主要做了以下几方面的事情：

（1）许可是在构造方法时传入的；

（2）许可存放在状态变量state中；

（3）尝试获取一个许可的时候，则state的值减1；

（4）当state的值为0的时候，则无法再获取许可；

（5）释放一个许可的时候，则state的值加1；

（6）许可的个数可以动态改变；

2）内部类NonfairSync

介绍了Sync之后，再来看看其子类NonfairSync（非公平模式同步器），其内部实现原理如下所示：

// java.util.concurrent.Semaphore.NonfairSync
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = -2694183684443567898L;
    // 构造方法，调用父类的构造方法
    NonfairSync(int permits) {
        super(permits);
    }
    // 尝试获取许可，调用父类的nonfairTryAcquireShared()方法
    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }
}

从源码第10行可以知道，非公平模式下，会直接调用父类的nonfairTryAcquireShared()方法去尝试获取许可。

3）内部类FairSync

接下来，再看看FairSync，源码如下：

// java.util.concurrent.Semaphore.FairSync
static final class FairSync extends Sync {
    private static final long serialVersionUID = 2014338818796000944L;
    // 构造方法，调用父类的构造方法
    FairSync(int permits) {
        super(permits);
    }
    // 尝试获取许可
    protected int tryAcquireShared(int acquires) {
        for (;;) {
            // 公平模式需要检测是否前面有排队的
            // 如果有排队的直接返回失败
            if (hasQueuedPredecessors())
                return -1;
            // 没有排队的再尝试更新state的值
            int available = getState();
            int remaining = available - acquires;
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                return remaining;
        }
    }
}

通过名称，大概也可以知道，FairSync是基于一种公平模式下的同步器，而当时我有所疑惑的是，如何实现所谓的公平模式？

其实读完之后，可以发现，公平模式主要借助队列FIFO方式进行实现，具体可以看hasQueuedPredecessors()方法。这也是该模式与非公平模式获取许可的核心区别。

其中hasQueuePredecessors()是顶层父类AQS提供的方法，用于检测当前节点入队后，该节点是否为头结点。

public final boolean hasQueuedPredecessors() {
    // The correctness of this depends on head being initialized
    // before tail and on head.next being accurate if the current
    // thread is first in queue.
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

4）构造方法

通过Semaphore的构造方法可知，Semaphore在初始化时，默认使用非公平模式去获取一个Semaphore的实例，当然，可以通过指定公平/非公平的方式来获取一个Semaphore实例。而入参permit就是前文所说的，许可数量

// 构造方法，创建时要传入许可次数，默认使用非公平模式
public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}
// 构造方法，需要传入许可次数，及是否公平模式
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

5）Semaphore中常用方法

1）acquire()；

通过可中断方式获取一个许可，如果尝试获取许可失败，则会进入到AQS队列中排队。

public void acquire() throws InterruptedException { sync.acquireSharedInterruptibly(1); }

2）acquireUninterruptibly()方法

获取一个许可，非中断方式，如果尝试获取许可失败，会进入AQS的队列中排队。

public void acquireUninterruptibly() { sync.acquireShared(1); }

3）tryAcquire()方法

尝试获取一个许可，使用Sync的非公平模式尝试获取许可方法，不论是否获取到许可都返回，只尝试一次，不会进入队列排队。

public boolean tryAcquire() {
    return sync.nonfairTryAcquireShared(1) >= 0;
}

4）tryAcquire(long timeout, TimeUnit unit)方法

尝试获取一个许可，先尝试一次获取许可，如果失败则会等待timeout时间，这段时间内都没有获取到许可，则返回false，否则返回true；

public boolean tryAcquire(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

5）release()方法

释放一个许可，释放一个许可时state的值会加1，并且会唤醒下一个等待获取许可的线程。

public void release() {
    sync.releaseShared(1);
}

6）acquire(int permits)方法

一次获取多个许可，可中断方式。

public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

7）acquireUninterruptibly(int permits)方法

一次获取多个许可，非中断方式。

public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
}

8）tryAcquire(int permits)方法

一次获取多个许可，可中断方式。

public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

9）acquireUninterruptibly(int permits)方法

一次获取多个许可，非中断方式

public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
}

10）tryAcquire(int permits)方法

一次尝试获取多个许可，只尝试一次。

public boolean tryAcquire(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.nonfairTryAcquireShared(permits) >= 0;
}

11）tryAcquire(int permits, long timeout, TimeUnit unit)方法

尝试获取多个许可，并会等待timeout时间，这段时间没获取到许可则返回false，否则返回true。

public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
    throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}

12）release(int permits)方法

一次释放多个许可，state的值会相应增加permits的数量。

public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}

13）availablePermits()方法

获取可用许可的次数

public int availablePermits() {
    return sync.getPermits();
}

14）drainPermits()方法

销毁当前可用的许可次数，对于已经获取的许可没有影响，会把当前剩余的许可全部销毁。换句话说，有10个许可，被取走了3个，剩下七个，此时调用该方法，会全部销毁7个许可，而已经取走的三个许可则不受影响

public int drainPermits() {
    return sync.drainPermits();
}

15）reducePermits(int reduction)方法

减少许可的次数。

protected void reducePermits(int reduction) {
    if (reduction < 0) throw new IllegalArgumentException();
    sync.reducePermits(reduction);
}

虽然列了这么15个方法，有点杂乱，但是可以发现的是，本质上都是对获取/释放许可，销毁/减少许可等底层基础方法的封装和调用。

如tryAcquire() 和 tryAcquire(permit)，其区别就是尝试一次获取单个许可和尝试获取多个许可的区别，所以，本质上来说，理解了Sync、NonFairSync和FairSync这三个类提供的方法后，对于后续Semaphore提供的方法的解读，无非就是对这些类里提供的方法的扩充和封装。

而这里需要注意的是，在阅读源码的时候，中断/非中断这个字眼重复出现，其实还是要回归到AQS里去理解，后文将继续展开描述。

3 Semaphore实战示例

package servlet;

import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @ClassName SemaphoreTest
 * @Descrpition 
 * @Author 
 * @Date 2019/8/13 上午10:17
 * @Version 1.0
 **/
public class SemaphoreTest {
    //假设有一个车库 拥有有3个停车位  那么permit=3 为允许停放车辆数，即驶入许可
    private static final Semaphore semaphore = new Semaphore(3);
    private static final ExecutorService executorService = Executors.newCachedThreadPool();

    private static class CarThread implements Runnable {
        private String name;
        private String carNumber;

        public CarThread(String name, String carNumber) {
            this.name = name;
            this.carNumber = carNumber;
        }

        @Override
        public void run() {
            try {
                // 获取进入车库许可
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + ":请注意，车牌号：" + carNumber + "进入车库，当前时间" + Timestamp.valueOf(LocalDateTime.now()));
                Thread.sleep(2000);
                System.out.println("当前车库车位空余数：" + semaphore.availablePermits());
                System.out.println(carNumber + "驶出车库,当前时间:" + Timestamp.valueOf(LocalDateTime.now()));
                semaphore.release();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        String[] name = {"Car1", "Car2", "Car3", "Car4", "Car5", "Car6", "Car7"};
        String[] carNumber = {"浙A99999", "浙A88888", "浙A77777", "浙A123333", "浙A123111", "浙A66666", "浙A55555"};
        for (int i = 0; i < 7; i++) {
            CarThread carThread = new CarThread(name[i], carNumber[i]);
            executorService.submit(carThread);
        }
    }
}

运行结果如下图所示：

/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/bin/java "-javaagent:/Applications/IntelliJ IDEA.app/Contents/lib/idea_rt.jar=61341:/Applications/IntelliJ IDEA.app/Contents/bin" -Dfile.encoding=UTF-8 -classpath /Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/charsets.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/deploy.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/cldrdata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/dnsns.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/jaccess.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/jfxrt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/localedata.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/nashorn.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunec.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunjce_provider.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/sunpkcs11.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/ext/zipfs.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/javaws.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jce.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jfr.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jfxswt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jsse.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/management-agent.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/plugin.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/resources.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/rt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/ant-javafx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/dt.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/javafx-mx.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/jconsole.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/packager.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/sa-jdi.jar:/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/lib/tools.jar:/Users/qudi/Documents/JavaStudy/MyServlet/out/production/MyServlet:/Users/qudi/Downloads/devEnv/apache-tomcat-8.5.42/lib/jsp-api.jar:/Users/qudi/Downloads/devEnv/apache-tomcat-8.5.42/lib/servlet-api.jar servlet.SemaphoreTest
pool-1-thread-2:请注意，车牌号：浙A88888进入车库，当前时间2019-08-13 10:43:58.43
pool-1-thread-1:请注意，车牌号：浙A99999进入车库，当前时间2019-08-13 10:43:58.43
pool-1-thread-3:请注意，车牌号：浙A77777进入车库，当前时间2019-08-13 10:43:58.43
当前车库车位空余数：0
当前车库车位空余数：0
当前车库车位空余数：0
浙A88888驶出车库,当前时间:2019-08-13 10:44:00.436
浙A77777驶出车库,当前时间:2019-08-13 10:44:00.436
浙A99999驶出车库,当前时间:2019-08-13 10:44:00.436
pool-1-thread-4:请注意，车牌号：浙A123333进入车库，当前时间2019-08-13 10:44:00.436
pool-1-thread-5:请注意，车牌号：浙A123111进入车库，当前时间2019-08-13 10:44:00.436
pool-1-thread-6:请注意，车牌号：浙A66666进入车库，当前时间2019-08-13 10:44:00.437
当前车库车位空余数：0
当前车库车位空余数：0
当前车库车位空余数：0
浙A123111驶出车库,当前时间:2019-08-13 10:44:02.438
浙A123333驶出车库,当前时间:2019-08-13 10:44:02.439
浙A66666驶出车库,当前时间:2019-08-13 10:44:02.438
pool-1-thread-7:请注意，车牌号：浙A55555进入车库，当前时间2019-08-13 10:44:02.439
当前车库车位空余数：2
浙A55555驶出车库,当前时间:2019-08-13 10:44:04.442

其实观察一下，就可以发现，在main方法中，采用for循环的方式，创建线程并提交给线程池执行，但从输出结果来看，车库车位空余数量并没有与我预期的结果一致，简单分析了一下，是因为在Semaphore.acquire()和Semaphore.release()这两个方法之间的代码，并非像Lock那样同一时间只有一个线程执行，换句话说，是因为并发执行造成车库空余车位数量不准确的缘故，如果想要改进的话，可以配合ReentrantLock来实现。

四、个人感想

读了Semaphore之后，有了几点感悟吧：

1、Semaphore是信号量，用于管理一组资源。其内部是基于AQS的共享模式，AQS的状态表示许可证的数量，在许可证数量不够时，线程将会被挂起；而一旦有一个线程释放一个资源，那么就有可能重新唤醒等待队列中的线程继续执行。

2、读了Semaphore之后，发现还是需要回归到AQS上，去理解，并在此基础上进一步深入阅读，触类旁通。

3、在Semaphore获取/释放许可这个动作之间，并非原子操作，与ReentrantLock的lock和unlock是有本质区别的。

Q蛋黄酱

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
随笔系列之Semaphore

前言：在前段时间，学习JMM以及synchronize、volatile和ReentrantLock之后，本着好奇的心思，想研究一下juc包下的其他并发控制工具，于是乎，便着手Semaphore进行研究。一、什么是SemaphoreSemaphore，翻译过来也叫信号量，也是JUC包下一个重要的并发工具，其核心功能是为了限制并发线程数量，也可以理解为限流。虽然说，翻译过来称之...
复制链接

扫一扫

专栏目录