AQS同步组件--Semaphore

DobbyKim 发布于2019-08-19 11:41 / 1594人阅读

摘要：演示代码获取一个许可释放一个许可我们在执行方式前后包裹上和，这样其实我们就相当于一个单线程在执行。尝试获取一个许可释放一个许可这次我们使用的是一个方法，这个方法的第一个参数是表示等待毫秒，第二参数是表示多长时间尝试一次，表示毫秒。

Semaphore

什么是Semaphore？

是用于控制某个资源同一时间被线程访问的个数，提供acquire（）和release（）方法，acquire获取一个许可，如果没有获取的到就等待，release是在操作完成后释放一个许可，Semaphore维护了当前访问的个数，通过同步机制来控制同时访问的个数，在数据结构里链表中的节点是可以无限个的，而Semaphore里维护的是一个有大小的限链表。

Semaphore的使用场景

Semaphore用于仅能提供有限访问的资源,比如数据库中的链接数只有20但是我们上层应用数可能远大于20，如果同时都对数据库链接进行获取，那很定会因为链接获取不到而报错，所以我们就要对数据库链接的访问进行控制。

演示代码

@Slf4j
public class SemaphoreExample1 {

    private final static int threadCount = 20;

    public static void main(String[] args) throws Exception {

        ExecutorService exec = Executors.newCachedThreadPool();

        final Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    semaphore.acquire(); // 获取一个许可
                    test(threadNum);
                    semaphore.release(); // 释放一个许可
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

我们在执行 test(threadNum)方式前后包裹上acquire和release，这样其实我们就相当于一个单线程在执行。当执行acquire后就只能等待执行release后再执行新的线程，然后我们在acquire()和release（）都是没有传参也就是1，每次只允许一个线程执行，如果我们改成

semaphore.acquire(3); // 获取多个许可
test(threadNum);
semaphore.release(3); // 释放多个许可

那么我们就是每3个3个执行直到把线程池中的线程执行完。在打印的日志中我们也可以看到是每三个每三个打印。

假设我们的数据库允许获取连接是3剩余的获取线程我们不想要只想丢弃改如何实现？

Semaphore提供了一个尝试获取许可的方法，tryAcquire（）尝试获取许可成功就执行，尝试获取许可失败就丢弃线程。下面看代码

@Slf4j
public class SemaphoreExample3 {

    private final static int threadCount = 20;

    public static void main(String[] args) throws Exception {

        ExecutorService exec = Executors.newCachedThreadPool();

        final Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    if (semaphore.tryAcquire()) { // 尝试获取一个许可
                        test(threadNum);
                        semaphore.release(); // 释放一个许可
                    }
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

这段代码执行结果就只打印了3行日志，其他的线程就被丢弃了。tryAcquire()共提供如下几种方法。

我们用一个例子来演示一下参数的方法的使用。

@Slf4j
public class SemaphoreExample4 {

    private final static int threadCount = 20;

    public static void main(String[] args) throws Exception {

        ExecutorService exec = Executors.newCachedThreadPool();

        final Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(() -> {
                try {
                    if (semaphore.tryAcquire(5000, TimeUnit.MILLISECONDS)) { // 尝试获取一个许可
                        test(threadNum);
                        semaphore.release(); // 释放一个许可
                    }
                } catch (Exception e) {
                    log.error("exception", e);
                }
            });
        }
        exec.shutdown();
    }

    private static void test(int threadNum) throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

这次我们使用的是一个tryAcquire(5000, TimeUnit.MILLISECONDS))方法，这个方法的第一个参数是表示等待5000毫秒，第二参数是表示多长时间尝试一次，TimeUnit.MILLISECONDS表示1毫秒。这时候我们会发现20个线程都执行了，为什么会这样呢？因为我们在执行时等待超时时间是5秒，每次执行就是sleep 1秒，所以可以获取成tryAcquire进而执行。

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/77671.html

AQS同步组件--ReentrantLock与锁

摘要：性能较好是因为避免了线程进入内核的阻塞状态请求总数同时并发执行的线程数我们首先使用声明一个所得实例，然后使用进行加锁和解锁操作。 ReentrantLock与锁 Synchronized和ReentrantLock异同可重入性：两者都具有可重入性锁的实现：Synchronized是依赖jvm实现的，ReentrantLock是jdk实现的。（我们可以理解为一个是操作系统层面的实现...

dcr309duan 2019-08-19 11:41 评论0 收藏0
Java多线程进阶（二十）—— J.U.C之synchronizer框架：Semaphore

摘要：当线程使用完共享资源后，可以归还许可，以供其它需要的线程使用。所以，并不会阻塞调用线程。立即减少指定数目的可用许可数。方法用于将可用许可数清零，并返回清零前的许可数六的类接口声明类声明构造器接口声明 showImg(https://segmentfault.com/img/bVbfdnC?w=1920&h=1200); 本文首发于一世流云的专栏：https://segmentfault...

boredream 2019-08-19 10:54 评论0 收藏0
AbstractQueuedSynchronizer 原理分析 - 独占/共享模式

摘要：简介抽象队列同步器，以下简称出现在中，由大师所创作。获取成功则返回，获取失败，线程进入同步队列等待。响应中断版的超时响应中断版的共享式获取同步状态，同一时刻可能会有多个线程获得同步状态。 1.简介 AbstractQueuedSynchronizer （抽象队列同步器，以下简称 AQS）出现在 JDK 1.5 中，由大师 Doug Lea 所创作。AQS 是很多同步器的基础框架，比如 ...

pf_miles 2019-08-16 11:14 评论0 收藏0
AbstractQueuedSynchronizer 原理分析 - 独占/共享模式

摘要：简介抽象队列同步器，以下简称出现在中，由大师所创作。获取成功则返回，获取失败，线程进入同步队列等待。响应中断版的超时响应中断版的共享式获取同步状态，同一时刻可能会有多个线程获得同步状态。 1.简介 AbstractQueuedSynchronizer （抽象队列同步器，以下简称 AQS）出现在 JDK 1.5 中，由大师 Doug Lea 所创作。AQS 是很多同步器的基础框架，比如 ...

gekylin 2019-08-19 10:44 评论0 收藏0
长文慎入-探索Java并发编程与高并发解决方案

摘要：所有示例代码请见下载于基本概念并发同时拥有两个或者多个线程，如果程序在单核处理器上运行多个线程将交替地换入或者换出内存这些线程是同时存在的，每个线程都处于执行过程中的某个状态，如果运行在多核处理器上此时，程序中的每个线程都所有示例代码,请见/下载于 https://github.com/Wasabi1234... showImg(https://upload-images.jians...

SimpleTriangle 2019-08-16 13:54 评论0 收藏0