呵,Semaphore,就这?

信号量Semaphore详解 大家应该都用过关键字加锁,用来保证某个时刻只允许一个线程运行。那么如果控制某个时刻允许指定数量的线程执行,有什么好的办法呢?答案就是JUC提供的信号量Semaphore。Semaphore(信号量)可以用来限制能同时访问共享资源的线程上限,它内部维护了一个许可的变量,也就是线程许可的数量Semaphore的许可数量如果小于0个,就会阻塞获取,直到有线程释放许可Semaphore是一个非重入锁构造方法permits表示许可线程的数量fair表示公平性,如果设为true。 阅读详情

认识 Semaphore

Semaphore 是什么

Semaphore 一般译作 信号量,它也是一种线程同步工具,主要用于多个线程对共享资源进行并行操作的一种工具类。它代表了一种许可的概念,是否允许多线程对同一资源进行操作的许可,使用 Semaphore 可以控制并发访问资源的线程个数。

Semaphore 的使用场景

Semaphore 的使用场景主要用于流量控制,比如数据库连接,同时使用的数据库连接会有数量限制,数据库连接不能超过一定的数量,当连接到达了限制数量后,后面的线程只能排队等前面的线程释放数据库连接后才能获得数据库连接。

再比如交通公路上的红绿灯,绿灯亮起时只能让 100 辆车通过,红灯亮起不允许车辆通过。

再比如停车场的场景中,一个停车场有有限数量的车位,同时能够容纳多少台车,车位满了之后只有等里面的车离开停车场外面的车才可以进入。

Semaphore 使用

下面我们就来模拟一下停车场的业务场景:在进入停车场之前会有一个提示牌,上面显示着停车位还有多少,当车位为 0 时,不能进入停车场,当车位不为 0 时,才会允许车辆进入停车场。所以停车场有几个关键因素:停车场车位的总容量,当一辆车进入时,停车场车位的总容量 - 1,当一辆车离开时,总容量 + 1,停车场车位不足时,车辆只能在停车场外等待。

public class CarParking {

    private static Semaphore semaphore = new Semaphore(10);

    public static void main(String[] args){

        for(int i = 0;i< 100;i++){

            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("欢迎 " + Thread.currentThread().getName() + " 来到停车场");
                    // 判断是否允许停车
                    if(semaphore.availablePermits() == 0) {
                        System.out.println("车位不足,请耐心等待");
                    }
                    try {
                        // 尝试获取
                        semaphore.acquire();
                        System.out.println(Thread.currentThread().getName() + " 进入停车场");
                        Thread.sleep(new Random().nextInt(10000));// 模拟车辆在停车场停留的时间
                        System.out.println(Thread.currentThread().getName() + " 驶出停车场");
                        semaphore.release();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, i + "号车");

            thread.start();
        }

    }

}

在上面这段代码中,我们给出了 Semaphore 的初始容量,也就是只有 10 个车位,我们用这 10 个车位来控制 100 辆车的流量,所以结果和我们预想得很相似,即大部分车都在等待状态。但是同时仍允许一些车驶入停车场,驶入停车场的车辆,就会 semaphore.acquire 占用一个车位,驶出停车场时,就会 semaphore.release 让出一个车位,让后面的车再次驶入。

Semaphore 信号量的模型

上面代码虽然比较简单,但是却能让我们了解到一个信号量模型的五脏六腑。下面是一个信号量的模型:

来解释一下 Semaphore ,Semaphore 有一个初始容量,这个初始容量就是 Semaphore 所能够允许的信号量。在调用 Semaphore 中的 acquire 方法后,Semaphore 的容量 -1,相对的在调用 release 方法后,Semaphore 的容量 + 1,在这个过程中,计数器一直在监控 Semaphore 数量的变化,等到流量超过 Semaphore 的容量后,多余的流量就会放入等待队列中进行排队等待。等到 Semaphore 的容量允许后,方可重新进入。

Semaphore 所控制的流量其实就是一个个的线程,因为并发工具最主要的研究对象就是线程。

它的工作流程如下

这幅图应该很好理解吧,这里就不再过多解释啦。

Semaphore 深入理解

在了解 Semaphore 的基本使用和 Semaphore 的模型后,下面我们还是得从源码来和你聊一聊 Semaphore 的种种细节问题,因为我写文章最核心的东西就是想让我的读者 了解 xxx,看这一篇就够了,这是我写文章的追求,好了话不多说,源码走起来!

Semaphore 基本属性

Semaphore 中只有一个属性

private final Sync sync;

Sync 是 Semaphore 的同步实现,Semaphore 保证线程安全性的方式和 ReentrantLock 、CountDownLatch 类似,都是继承于 AQS 的实现。同样的,这个 Sync 也是继承于 AbstractQueuedSynchronizer 的一个变量,也就是说,聊 Semaphore 也绕不开 AQS,所以说 AQS 真的太重要了。

Semaphore 的公平性和非公平性

那么我们进入 Sync 内部看看它实现了哪些方法

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))
        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))
        return current;
    }
  }
}

首先是 Sync 的初始化,内部调用了 setState 并传递了 permits ,我们知道,AQS 中的 State 其实就是同步状态的值,而 Semaphore 的这个 permits 就是代表了许可的数量。

getPermits 其实就是调用了 getState 方法获取了一下线程同步状态值。后面的 nonfairTryAcquireShared 方法其实是在 Semaphore 中构造了 NonfairSync 中的 tryAcquireShared 调用的

这里需要提及一下什么是 NonfairSync,除了 NonfairSync 是不是还有 FairSync 呢?查阅 JDK 源码发现确实有。

那么这里的 FairSync 和 NonfairSync 都代表了什么?为什么会有这两个类呢?

事实上,Semaphore 就像 ReentrantLock 一样,也存在“公平”和"不公平"两种,默认情况下 Semaphore 是一种不公平的信号量

Semaphore 的不公平意味着它不会保证线程获得许可的顺序,Semaphore 会在线程等待之前为调用 acquire 的线程分配一个许可,拥有这个许可的线程会自动将自己置于线程等待队列的头部。

当这个参数为 true 时,Semaphore 确保任何调用 acquire 的方法,都会按照先入先出的顺序来获取许可。

final int nonfairTryAcquireShared(int acquires) {
  for (;;) {
    // 获取同步状态值
    int available = getState();
    // state 的值 - 当前线程需要获取的信号量(通常默认是 -1),只有
    // remaining > 0 才表示可以获取。
    int remaining = available - acquires;
    // 先判断是否小于 0 ,如果小于 0 则表示无法获取,如果是正数
    // 就需要使用 CAS 判断内存值和同步状态值是否一致,然后更新为同步状态值 - 1
    if (remaining < 0 ||
        compareAndSetState(available, remaining))
      return remaining;
  }
}

从上面这幅源码对比图可以看到,NonfairSync 和 FairSync 最大的区别就在于 tryAcquireShared 方法的区别。

NonfairSync 版本中,是不会管当前等待队列中是否有排队许可的,它会直接判断信号许可量和 CAS 方法的可行性。

FairSync 版本中,它首先会判断是否有许可进行排队,如果有的话就直接获取失败。

这时候可能就会有读者问了,你上面说公平性和非公平性的区别一直针对的是 acquire 方法来说的,怎么现在他们两个主要的区别在于 tryAcquireShared 方法呢?

别急,让我们进入到 acquire 方法一探究竟

可以看到,在 acquire 方法中,会调用 tryAcquireShared 方法,根据其返回值判断是否调用 doAcquireSharedInterruptibly 方法,更多关于 doAcquireSharedInterruptibly 的使用分析,请参考读者的这篇文章

一文搞懂 CountDownLatch 用法和源码!

这里需要注意下,acquire 方法具有阻塞性,而 tryAcquire 方法不具有阻塞性。
这也就是说,调用 acquire 方法如果获取不到许可,那么 Semaphore 会阻塞,直到有可用的许可。而 tryAcquire 方法如果获取不到许可会直接返回 false。

这里还需要注意下 acquireUninterruptibly 方法,其他 acquire 的相关方法要么是非阻塞,要么是阻塞可中断,而 acquireUninterruptibly 方法不仅在没有许可的情况下执着的等待,而且也不会中断,使用这个方法时需要注意,这个方法很容易在出现大规模线程阻塞而导致 Java 进程出现假死的情况。

有获取许可相对应的就有释放许可,但是释放许可不会区分到底是公平释放还是非公平释放。不管方式如何都是释放一个许可给 Semaphore ,同样的 Semaphore 中的许可数量会增加。

在上图中调用 tryReleaseShared 判断是否能进行释放后,再会调用 AQS 中的releasedShared 方法进行释放。

上面这个释放流程只是释放一个许可,除此之外,还可以释放多个许可

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

后面这个 releaseShared 的释放流程和上面的释放流程一致。

其他 Semaphore 方法

除了上面基本的 acquire 和 release 相关方法外,我们也要了解一下 Semaphore 的其他方法。Semaphore 的其他方法比较少,只有下面这几个

drainPermits :获取并退还所有立即可用的许可,其实相当于使用 CAS 方法把内存值置为 0

reducePermits:和 nonfairTryAcquireShared 方法类似,只不过 nonfairTryAcquireShared 是使用 CAS 使内存值 + 1,而 reducePermits 是使内存值 - 1 。

isFair:对 Semaphore 许可的争夺是采用公平还是非公平的方式,对应到内部的实现就是 FairSync 和 NonfairSync。

hasQueuedThreads:当前是否有线程由于要获取 Semaphore 许可而进入阻塞。

getQueuedThreads:返回一个包含了等待获取许可的线程集合。

getQueueLength:获取正在排队而进入阻塞状态的线程个数。

Semaphore的使用详解 Semaphore在初始化时需要指定许可证数,Semaphore#acquire方法会尝试获取一定数量的许可证,若许可证数量不足,则当前线程进入阻塞状态。相应地,获取到了许可证的线程,在执行完毕后,需要调用Semaphore#release方法来归还许可证。 阅读详情

相关推荐

Semaphore源码分析

一、Semaphore介绍 Semaphore,俗称信号量,它是操作系统PV操作原语在JDK中的实现,同样,它也是基于AbstractQueuedSynchronizer来实现的。 Semaphore通俗理解就是常说的共享锁,它可以定义共享资源的个数,只要共享资源还有,其他线程就可以执行,否则就会被阻塞。 而关于操作系统中PV操作的原语可以参考《详解进程同步》这篇文章中对信号量的详细介绍 Semaphore的功能非常强大,大小为1的信号量,它的功能就类似于互斥锁(ReentrantLock),同时只能有一个

sermonlizhi的博客 1132

Semaphore详解

判断是否满足获取锁条件,关键方法.若获取锁成功,则也会修改state.若获取锁失败,关键方法阻塞的获取锁.添加到双向链表若是头节点后继,则尝试获取锁,否者则判断进入睡眠等待唤醒,唤醒后继续执行3.2若不进入睡眠,则直接运行到3.2步释放N个许可,因为存在并发释放,需要CAS确保设置更新后的值.唤醒双向链表中有效的等待节点.(可能存在并发问题,引入PROPAGATE状态)被唤醒的节点调用获取锁的流程....

Admans的专栏 2万+

C#:实现图像相似度算法​(附完整源码)

C#:实现图像相似度算法​(附完整源码)

希望我的博客,能帮上你解决学习中工作中所遇到的问题 1511

Semaphore 详解

可以把它简单的理解成我们停车场入口立着的那个显示屏,每有一辆车进入停车场显示屏就会显示剩余车位减1,每有一辆车从停车场出去,显示屏上显示的剩余车辆就会加1,当显示屏上的剩余车位为0时,停车场入口的栏杆就不会再打开,车辆就无法进入停车场了,直到有一辆车从停车场出去为止。每个停车场入口都有一个提示牌,上面显示着停车场的剩余车位还有多少,当剩余车位为0时,不允许车辆进入停车场,直到停车场里面有车离开停车场,这时提示牌上会显示新的剩余车位数。3、每有一辆车驶出停车场后,显示牌的剩余车位数响应的加1。

qq_58148854的博客 2607

c#图像相似度比较demo

在网上找的用灰度直方图方法计算相似度的算法写的小例子,经测试效果还可以 在网上找的用灰度直方图方法计算相似度的算法写的小例子,经测试效果还可以

C#比较图片相似度,两张图片有多少相似

C#比较照片的相似度,之前找的一个不好用,现在这个测试了一下还是不错的,有需要可以下载看一下

Java Semaphore详解

本文目录1、介绍2、主要方法3、Semaphore登录限流示例 1、介绍 Semaphore(信号量)是用来控制同时访问特定资源的线程数量,通过协调各个线程以保证合理地使用公共资源。 Semaphore通过使用计数器来控制对共享资源的访问。 如果计数器大于0,则允许访问。 如果为0,则拒绝访问。 计数器所计数的是允许访问共享资源的许可。 因此,要访问资源,必须从信号量中授予线程许可。 2、主要方法 void acquire() :从信号量获取一个许可,如果无可用许可前将一直阻塞等待, void ac

warybee 1万+

c# 图片相似度处理,opencv

c# OpenCvSharp 图片相似度比较,四种方法对比,SSIM,PSNR,灰度直方图比较,RGB三通道全彩直方图比较,亲测,效果不错。

Semaphore使用及手写实现

Semaphore(信号量)是用来控制同时访问特定资源的线程数量,它通过协调各个线程,以保证合理的使用公共资源。 作用:控制同时访问某个资源的最大线程数,一般用来限流。 API 构造器 Semaphore(int permits) 许可证数量 Semaphore(int permits, boolean fair) 许可证数量,使用公平锁/非公平锁 Methods void a...

程序员小潘 6805

c# 图像相似度对比详情完整代码介绍讲解.docx

安装Emgu CV库: 在Visual Studio安装Emgu CV,可以在NuGet包管理器中搜索Emgu.CV,然后安装最新版本。 解决方案中添加示例图像: 在解决方案中新建一个文件夹,并将几张图像放入其中。这些图像将用于对比相似度。 新建控制台应用程序: 在Visual Studio中新建控制台应用程序,并在代码中引用Emgu.CV库。 引入Emgu.CV和System.IO库 读取需要对比的两张图像 将两张图像转换为灰度图像以简化计算 使用MatchTemplate方法计算图像相似度,并将结果进行归一化 最后将相似度乘以100并保留两位小数 使用上面的代码,便可以轻松实现对比两张图像的相似度,进行图像匹配等操作。

Zigbee通信(CC2530终端 + ESP32-C6协调器)

实现了CC2530 zigbee终端与ESP32-C6 zigbee协调器的通信交互。

Ecsply的博客 2571

JUC系列——Semaphore

简介 Semaphore是一种在多线程环境下负责协调各个线程,以保证它们能够正确、合理的使用公共资源。 Semaphore是一种计数信号量,用于管理一组资源,内部是基于AQS的共享模式。它相当于控制使用公共资源的活动线程的数量。 主要方法 主要方法: Semaphore(int permits):构造方法,创建具有给定许可数的计数信号量并设置为非公平信号量。 Semaphore(int perm...

耘田 1750

FPGA时序约束:从时钟树到数据路径的深度解析与优化策略

本文深入解析FPGA时序约束的核心技术与优化策略,涵盖时钟树结构分析、时序报告解读和数据路径优化。重点探讨Vivado工具中的时序约束方法,包括时钟定义、异常约束和物理优化,帮助工程师掌握寄存器级时序分析和系统级协同设计,实现高性能FPGA设计。

u5v6w7的博客 653

Semaphore信号量详解

Semaphore是一个强大而灵活的同步工具,它允许我们细粒度地控制对资源的并发访问。通过合理地使用Semaphore,我们可以确保系统在高并发环境下的稳定性和性能。

大乐乐 1974

W5500 TCP服务器状态机详解:从SOCK_CLOSED到SOCK_ESTABLISHED的完整流程

本文深入解析W5500芯片作为TCP服务器时的状态机转换流程,从SOCK_CLOSED到SOCK_ESTABLISHED的完整链路实践。通过硬件协议栈架构分析、状态机全流程拆解及异常处理方案,帮助开发者构建高可靠性的嵌入式网络服务端,优化TCP连接性能与稳定性。

Jerry的专栏 1167

【Unity 实用工具篇】✨| 使用Fungus插件制作一个对话系统,简单好学易上手

今天带来的是Unity中一款简单易用的对话插件Fungus,它是一个免费的交互式的对话系统。 Fungus是Unity免费的一款开源的插件,它可以无代码的实现玩家与NPC之间的对话,并且支持本地化,对相机、Sprite及音乐音效的控制。 学会使用该插件就可以做一些对话剧情类的游戏了,还是非常好用的,下面就来学习一下Fungus具体怎么使用吧!

努力前行,总会成为自己心中的那道光 1万+

Semaphore的使用

  Semaphore也是一个线程同步的辅助类,可以维护当前访问自身的线程个数,并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数,例如,实现一个文件允许的并发访问数。 Semaphore的主要方法摘要:   void acquire():从此信号量获取一个许可,在提供一个许可前一直将线程阻塞,否则线程被中断。   void release():释放一个许可,将...

daxiang3255的博客 1837

Scale-up,scale-out技术概述

本文系统分析了Scale-up与Scale-out两种扩展技术在现代计算中的应用与发展。Scale-up通过增强单节点性能,适用于高耦合任务,而Scale-out通过横向扩展节点,实现高可用性和无限扩展。在芯片层面,Chiplet技术推动Scale-up发展;在数据中心层面,二者协同工作构建强大集群。光模块在长距离高带宽传输中发挥关键作用。文章对比了NVIDIA、AMD和Broadcom三家公司的技术路线,指出NVIDIA采用封闭生态,AMD选择开放标准,Broadcom则主导底层连接技术。未来发展方向将聚

元直的博客 1450

Semaphore GUI 详细介绍

Semaphore是一个开源的现代化GUI和API工具,专为简化Ansible、Terraform等DevOps工具的操作而设计。它提供直观的Web界面,支持多工具管理、任务调度、访问控制和日志记录等功能。安装方式多样,包括包管理器、Docker、二进制文件和Kubernetes部署,支持多种数据库选项。Semaphore特别适合团队协作和大规模项目管理,通过图形化界面降低命令行操作复杂度,提升自动化任务执行效率。

vortex5的博客 1335

Far planner 代码系列(35)动态障碍物预处理_激光雷达部分

主要讲解动态障碍物在激光雷达部分的剔除机制

博客 1059

15、SQL Server查询优化与CPU负载管理

本文深入探讨了SQL Server查询优化与CPU负载管理的关键技术,包括强制连接类型的使用、键查找问题的解决、索引设计的最佳实践、高CPU负载的排查与优化,以及并行性的利弊与调整策略。通过优化查询逻辑、合理设计索引、监控与管理CPU资源,可以显著提升SQL Server的性能和稳定性。适用于数据库开发人员和DBA进行性能调优参考。

pz8901234的博客 80

Semaphore

Semaphore 大厂面试题: 我们都知道ArrayList是线程不安全的,请编码写一个不安全的案例并给出解决方案? 公平锁/非公平锁/可重入锁/递归锁/自旋锁谈谈你的理解?请手写一个自旋锁。 CountDownLatch、CyclicBarrier、Semaphore使用过吗? 阻塞队列知道吗? 线程池用过吗?ThreadPoolExecutor谈谈你的理解? 线程池用过吗?生产...

泷泷养的乔小胖 4870

Python 【编程实战】玩转 MCP 在工具函数中获取请求 Headers 的正确姿势

本文介绍了如何在使用FastMCP框架的工具函数中获取请求信息。通过Context对象可以访问请求上下文,包括请求头、用户信息等。具体实现方式是在工具函数中注入ctx:Context参数,通过ctx.request_context.request获取Starlette的Request对象,从而访问headers等信息。Context参数的位置可以灵活放置,但建议放在函数参数的开头或末尾。这种机制为权限校验、数据打点等操作提供了统一访问不同通信模式下请求信息的解决方案。

wjianwei666的专栏 393

Semaphore是什么?

Semaphore简介 semaphore英文翻译为信号标,它是能控制允许多少线程去访问资源,也可以反馈线程在指定时间是否获得可执行权的信号,从而对这些超时未获取权力的线程做另行安排。 Semaphore使用场景 从简介中可以得知,semaphore可以限制并发访问数量,即为限流,像是微服务组件hystrix、sentinel等限流中间件都可使用此原理,当然随之而来,那些被限制通行的线程是被丢弃?还是去执行另外的流程,就是“降级服务”。 Semaphore使用demo 1、定义线程任务+降级服务

披甲上战场的博客 3949

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

上一篇: 好家伙!全网开源对标P5~P7程序员技术成长路线,阿里这次是真卷
下一篇: 框架篇:分布式理论CAP、BASE
Java佳佳
博客等级 码龄4年 216粉丝 286原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值