Semaphore

最新推荐文章于 2024-08-28 20:58:28 发布
最新推荐文章于 2024-08-28 20:58:28 发布
阅读量906 收藏 20
点赞数 11
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangk1996/article/details/140404156
版权

源码分析

通过其限制执行的线程数量，达到限流的效果，每个线程执行之前，会先获取令牌。

也是利用的了AQS机制来实现的，初始化的时候，将令牌数设置为statue.

公平模式和非公平模式的区别的，公平模式会先判断是否队列中已经有阻塞的先层了，如果有则不获取令牌。非公平锁，就直接获取剩余令牌，并且减去自己需要的令牌

在释放锁的时候，如果本来获取的令牌是3个，但是在释放的时候，释放四个，那么原先设置的令牌数也会增加。

内部类

Semaphore总共有三个内部类，并且三个内部类是紧密相关的。
在这里插入图片描述

Sync类

// 内部类，继承自AQS
abstract static class Sync extends AbstractQueuedSynchronizer {
    // 版本号
    private static final long serialVersionUID = 1192457210091910933L;
    
    // 构造函数
    Sync(int permits) {
        // 设置状态数
        setState(permits);
    }
    
    // 获取许可
    final int getPermits() {
        return getState();
    }

    // 共享模式下非公平策略获取
    final int nonfairTryAcquireShared(int acquires) {
        for (;;) { // 无限循环
            // 获取许可数
            int available = getState();
            // 剩余的许可
            int remaining = available - acquires;
            if (remaining < 0 ||
                compareAndSetState(available, remaining)) // 许可小于0或者比较并且设置状态成功
                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");
            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");
            if (compareAndSetState(current, next)) // 比较并进行设置成功
                return;
        }
    }

    // 获取并返回立即可用的所有许可
    final int drainPermits() {
        for (;;) { // 无限循环
            // 获取许可
            int current = getState();
            if (current == 0 || compareAndSetState(current, 0)) // 许可为0或者比较并设置成功
                return current;
        }
    }
}

NonfairSync类

NonfairSync类继承了Sync类，表示采用非公平策略获取资源，其只有一个tryAcquireShared方法，重写了AQS的该方法

static final class NonfairSync extends Sync {
    // 版本号
    private static final long serialVersionUID = -2694183684443567898L;
    
    // 构造函数
    NonfairSync(int permits) {
        super(permits);
    }
    // 共享模式下获取
    protected int tryAcquireShared(int acquires) {
        return nonfairTryAcquireShared(acquires);
    }
}

FairSync类

FairSync类继承了Sync类，表示采用公平策略获取资源，其只有一个tryAcquireShared方法，重写了AQS的该方法

protected int tryAcquireShared(int acquires) {
    for (;;) { // 无限循环
        if (hasQueuedPredecessors()) // 同步队列中存在其他节点
            return -1;
        // 获取许可
        int available = getState();
        // 剩余的许可
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining)) // 剩余的许可小于0或者比较设置成功
            return remaining;
    }
}

类属性

public class Semaphore implements java.io.Serializable {
    // 版本号
    private static final long serialVersionUID = -3222578661600680210L;
    // 属性 基于Semaphore对象的操作绝大多数都转移到了对sync的操作
    private final Sync sync;
  
  //该构造函数会创建具有给定的许可数和非公平的公平设置的Semaphore。
  public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

  //该构造函数会创建具有给定的许可数和给定的公平设置的Semaphore。
public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
  
}

核心方法

acquire

此方法从信号量获取一个(多个)许可，在提供一个许可前一直将线程阻塞，或者线程被中断。

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

//公平模式下
protected int tryAcquireShared(int acquires) {
    // 自旋
    for (;;) {
        // 判断是否已经存在阻塞的线程
        if (hasQueuedPredecessors())
            return -1;
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

//非公平模式下
protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
}

final int nonfairTryAcquireShared(int acquires) {
    // 自旋
    for (;;) {
        // 获取剩余的许可量
        int available = getState();
        // 扣减需要的信号量后的值
        int remaining = available - acquires;
        // 信号量不足 或者CAS替换state失败  返回扣减后的信号量值
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}
//公平和非公平模式的实现的区别是在公平模式的实现中会先判断是否已经存在阻塞的线程了，存在的话不会再去竞争获取许可了

该方法中将会调用Sync对象的acquireSharedInterruptibly(从AQS继承而来的方法)方法。acquireSharedInterruptibly方法在CountDownLatch中已经进行了分析。

最终可以获取大致的方法调用序列(假设使用非公平策略)

在这里插入图片描述

release

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

//Semaphore.Sync实现的tryReleaseShared方法逻辑
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");
        // CAS修改state
        if (compareAndSetState(current, next))
            return true;
    }
}

该方法中将会调用Sync对象的releaseShared(从AQS继承而来的方法)方法，而releaseShared方法在CountDownLatch中已经进行了分析。

最终可以获取大致的方法调用序列(假设使用非公平策略)

在这里插入图片描述

示例分析

import java.util.concurrent.Semaphore;

class MyThread extends Thread {
    private Semaphore semaphore;
    
    public MyThread(String name, Semaphore semaphore) {
        super(name);
        this.semaphore = semaphore;
    }
    
    public void run() {        
        int count = 3;
        System.out.println(Thread.currentThread().getName() + " trying to acquire");
        try {
            semaphore.acquire(count);
            System.out.println(Thread.currentThread().getName() + " acquire successfully");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release(count);
            System.out.println(Thread.currentThread().getName() + " release successfully");
        }
    }
}

public class SemaphoreDemo {
    public final static int SEM_SIZE = 10;
    
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(SEM_SIZE);
        MyThread t1 = new MyThread("t1", semaphore);
        MyThread t2 = new MyThread("t2", semaphore);
        t1.start();
        t2.start();
        int permits = 5;
        System.out.println(Thread.currentThread().getName() + " trying to acquire");
        try {
            semaphore.acquire(permits);
            System.out.println(Thread.currentThread().getName() + " acquire successfully");
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release();
            System.out.println(Thread.currentThread().getName() + " release successfully");
        }      
    }
}

//console
main trying to acquire
main acquire successfully
t1 trying to acquire
t1 acquire successfully
t2 trying to acquire
t1 release successfully
main release successfully
t2 acquire successfully
t2 release successfully

首先，生成一个信号量，信号量有10个许可，然后，main，t1，t2三个线程获取许可运行，根据结果，可能存在如下的一种时序。

在这里插入图片描述

如上图所示，首先，main线程执行acquire操作，并且成功获得许可，之后t1线程执行acquire操作，成功获得许可，之后t2执行acquire操作，由于此时许可数量不够，t2线程将会阻塞，直到许可可用。之后t1线程释放许可，main线程释放许可，此时的许可数量可以满足t2线程的要求，所以，此时t2线程会成功获得许可运行，t2运行完成后释放许可。下面进行详细分析。

main线程执行semaphore.acquire操作。主要的函数调用如下图所示。

在这里插入图片描述

此时，可以看到只是AQS的state变为了5，main线程并没有被阻塞，可以继续运行。

t1线程执行semaphore.acquire操作。主要的函数调用如下图所示。
在这里插入图片描述

此时，可以看到只是AQS的state变为了2，t1线程并没有被阻塞，可以继续运行。

t2线程执行semaphore.acquire操作。主要的函数调用如下图所示。

在这里插入图片描述

此时，t2线程获取许可不会成功，之后会导致其被禁止运行，值得注意的是，AQS的state还是为2。

t1执行semaphore.release操作。主要的函数调用如下图所示。

在这里插入图片描述

此时，t2线程将会被unpark，并且AQS的state为5，t2获取cpu资源后可以继续运行。

main线程执行semaphore.release操作。主要的函数调用如下图所示

在这里插入图片描述

此时，t2线程还会被unpark，但是不会产生影响，此时，只要t2线程获得CPU资源就可以运行了。此时，AQS的state为10。

t2获取CPU资源，继续运行，此时t2需要恢复现场，回到parkAndCheckInterrupt函数中，也是在should继续运行。主要的函数调用如下图所示。

在这里插入图片描述

此时，可以看到，Sync queue中只有一个结点，头节点与尾节点都指向该结点，在setHeadAndPropagate的函数中会设置头节点并且会unpark队列中的其他结点。

t2线程执行semaphore.release操作。主要的函数调用如下图所示。

在这里插入图片描述

t2线程经过release后，此时信号量的许可又变为10个了，此时Sync queue中的结点还是没有变化。

拓展

单独使用Semaphore是不会使用到AQS的条件队列的

不同于CyclicBarrier和ReentrantLock，单独使用Semaphore是不会使用到AQS的条件队列的，其实，只有进行await操作才会进入条件队列，其他的都是在同步队列中，只是当前线程会被park。

semaphore初始化有10个令牌，11个线程同时各调用1次acquire方法，会发生什么?

拿不到令牌的线程阻塞，不会继续往下运行。

semaphore初始化有10个令牌，一个线程重复调用11次acquire方法，会发生什么?

线程阻塞，不会继续往下运行。可能你会考虑类似于锁的重入的问题，但是，令牌没有重入的概念。你只要调用一次acquire方法，就需要有一个令牌才能继续运行。

semaphore初始化有1个令牌，1个线程调用一次acquire方法，然后调用两次release方法，之后另外一个线程调用acquire(2)方法，此线程能够获取到足够的令牌并继续运行吗?

能，原因是release方法会添加令牌，并不会以初始化的大小为准。

semaphore初始化有2个令牌，一个线程调用1次release方法，然后一次性获取3个令牌，会获取到吗?

能，原因是release会添加令牌，并不会以初始化的大小为准。Semaphore中release方法的调用并没有限制要在acquire后调用。

public class TestSemaphore2 {
    public static void main(String[] args) {
        int permitsNum = 2;
        final Semaphore semaphore = new Semaphore(permitsNum);
        try {
            System.out.println("availablePermits:"+semaphore.availablePermits()+",semaphore.tryAcquire(3,1, TimeUnit.SECONDS):"+semaphore.tryAcquire(3,1, TimeUnit.SECONDS));
            semaphore.release();
            System.out.println("availablePermits:"+semaphore.availablePermits()+",semaphore.tryAcquire(3,1, TimeUnit.SECONDS):"+semaphore.tryAcquire(3,1, TimeUnit.SECONDS));
        }catch (Exception e) {

        }
    }
}
永远别让世俗淹没生活的热情和浪漫
关注
  • 11
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Semaphore解析
zheng2780071070的博客
06-03 262
1. public void acquire() 2. public void acquireUninterruptibly()
semaphore
weixin_45417628的博客
09-08 163
import java.util.concurrent.Semaphore; /** * User:yang */ public class Thread{ public static void main(String[] args) throws InterruptedException { //c初始5 Semaphore semaphore = new Semaphore(5); //p，申请1 semaphore.acqu
sv-semaphore
喝水的面包
10-07 799
作用 信号是通过初始化一定数量的许可证，通过限制获得许可证的线程数量来阻塞未获取许可证达的线程，达到限制对特定资源访问的线程数量。 实现原理 所有多线程访问的控制方式归根结底都是对可共享地址进行管理，可以是简单的类似全局变量做的计数器判断，可以共享内存的数据结构的操作。 接口函数 new(): Creat a semaphore with a specified number kerys; get(): OBtian one or more keys from the busket; put(
信号量Semaphore
Jackie_Ryan的专栏
04-19 486
信号量实现多线程同步
Semaphore类
weixin_45339291的博客
04-20 792
Semaphore是信号量，是juc(java.util.concurrent)包下的工具类，用于控制同时访问资源的线程数量
semaphore讲解
cheng的博客
09-26 6210
一、简介 1、Semaphore底层是基于AbstractQueuedSynchronizer来实现的。Semaphore称为计数信号量，它允许n个任务同时访问某个资源，可以将信号量看做是在向外分发使用资源的许可证，只有成功获取许可证，才能使用资源。 2、它也是通过内部类Sync继承了AQS，它的方法几乎都是用的AQS的，少部分重写了AQS的方法，同时，它的信号量机制是通过AQS的state属性来操作的，变更state属性使用到了CAS操作保证变量的数据一致性。 3、它的方法几乎是通过Sync类，也就是AQ
sc_semaphore
zgcjaxj的博客
08-24 392
sc_semaphore的构造函数中需要给定一个初始的semaphore value ( int，必须配置为大于等于0的值 )。wait() 和trywait() 函数用来申请资源，如果成功则value -- （前提是当前value > 0），trywait()会返回0；如果此时value == 0，则申请失败，wait()函数会被block住，等待其他process调用post()让value > 0；post() 函数用来 释放资源，++value，notify等待的process。
semaphore完整搭建ansible部署方案
04-26
Semaphore 是一个强大的自动化部署工具，它使用 Ansible 来实现对多主机的配置管理。Ansible 是一个流行的 IT 自动化框架，它允许管理员通过编写 YAML 格式的 Playbook 来执行任务，如软件部署、配置管理和应用生命...
Semaphore 源码解析
04-25
Semaphore是Java并发编程中的一种重要工具，主要用于控制并发线程的访问权限，实现限流或资源的互斥访问。在高并发场景下，Semaphore能够有效地防止过多的线程同时访问共享资源，从而避免系统资源耗尽，提高系统性能...
C#多线程之Semaphore用法详解
01-21
Semaphore：可理解为允许线程执行信号的池子，池子中放入多少个信号就允许多少线程同时执行。 private static void MultiThreadSynergicWithSemaphore() { //0表示创建Semaphore时，拥有可用信号量数值 //1表示...
Swift-dispatch-semaphore
03-31
Swift中的`DispatchSemaphore`是GCD（Grand Central Dispatch）的一部分，它是Apple的多线程和并发解决方案。在iOS开发中，理解并熟练使用`DispatchSemaphore`对于优化代码性能和处理同步问题至关重要。本文将深入...
semaphore-develop.zip
04-26
Semaphore是一款强大的持续集成/持续部署(CI/CD)工具，主要设计用于自动化软件构建、测试和部署流程。在这个"semaphore-develop.zip"压缩包中，包含的应该是Semaphore的开发源码，这对于理解其内部工作原理、自定义...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2162
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 2519
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2780
linux上datax 安装以及使用
操作系统原子操作
zzt_is_me的博客
08-28 902
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
最新发布
weixin_39996520的博客
08-28 715
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 480
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
semaphore 数组
05-24
Semaphore是一种同步机制，可以用于多线程或多进程环境中控制并发访问资源的数量。它允许多个线程或进程同时访问一个共享资源，但是可以限制同一时间访问该资源的线程或进程的数量。 Semaphore数组是一组Semaphore对象的集合，每个Semaphore对象都有一个计数器和一个等待队列。当有一个线程或进程尝试获得一个Semaphore对象时，如果计数器大于0，那么该线程或进程可以获得Semaphore对象并将计数器减1；如果计数器等于0，那么该线程或进程将被阻塞并加入到等待队列中。当某个线程或进程释放Semaphore对象时，计数器将加1，并唤醒等待队列中的一个线程或进程。 Semaphore数组可以用于管理一组共享资源，例如数据库连接、文件句柄等。通过控制Semaphore对象的数量和初始值，可以限制并发访问这些共享资源的数量，从而避免竞争条件和死锁问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值