Linux —— 信号量

Linux —— 信号量

  • 什么是信号量
      • P操作（Wait操作）
      • V操作（Signal操作）
      • 信号量的类型
    • 一些接口
      • POSIX 信号量接口：
      • 其他相关命令：
  • 基于循环队列的生产者和消费者模型
    • 同步关系
  • 多生产多消费

我们今天接着来学习信号量：

什么是信号量

信号量（Semaphore）是一种用于操作系统中管理共享资源访问和同步的机制。它是一种特殊的数据结构，用来控制多个进程或线程对公共资源的访问，以防止多个进程同时对同一资源进行访问而导致的冲突问题。信号量维护了一个计数器，该计数器可以增加（通常称为V操作或Signal操作）或减少（称为P操作或Wait操作），并且这些操作都是原子的，即不可中断。

P操作（Wait操作）

  • 当一个进程想要访问一个受保护的资源时，它会执行P操作。
  • P操作会检查信号量的值，如果信号量大于0，则减1，并允许进程继续执行。
  • 如果信号量等于0，表示资源已被占用，进程将被阻塞（等待）直到信号量的值变为非零。

V操作（Signal操作）

  • 当一个进程完成对资源的访问后，它会执行V操作。
  • V操作会将信号量的值加1，表示释放了一个资源。
  • 如果有其他进程因为之前P操作而等待，此时可能会唤醒其中一个等待的进程。

信号量的类型

  • 二值信号量：这种信号量只有0和1两种状态，相当于一个互斥锁，用于实现互斥访问。
  • 计数信号量：可以用于控制有限数量的相同资源的访问，计数器的初始值代表资源的数量。

简单来说，信号量的本质就是一个容量为N的锁，跟一般的锁不一样，它可以放个多个线程访问临界资源，但是达到上限就不会让线程进入了，而让他们阻塞等待。

一些接口

在Linux环境下，信号量作为进程间通信的一种手段，主要用于同步和互斥控制。以下是Linux下信号量的一些常用接口，主要涉及System V信号量和POSIX信号量两种类型：

POSIX 信号量接口：

  1. sem_init(sem_t *sem, int pshared, unsigned int value):
    在这里插入图片描述
  • 初始化一个POSIX信号量。sem 是信号量的地址，pshared 指定信号量是否可以在多进程中共享（如果为1则是共享的），value 是信号量的初始值。
  1. sem_wait(sem_t *sem):[
    在这里插入图片描述
  • 执行P操作，如果信号量的值大于0，则减1并继续执行；否则，进程将被阻塞直到信号量的值大于0。
  1. sem_post(sem_t *sem):
    在这里插入图片描述
  • 执行V操作，增加信号量的值，如果因此唤醒了等待的进程，则会选择一个进行唤醒。
  1. sem_destroy(sem_t *sem):
    在这里插入图片描述
  • 销毁一个POSIX信号量。
  1. sem_getvalue(sem_t *sem, int *sval):
    在这里插入图片描述
  • 获取POSIX信号量的当前值，sval 是存储信号量值的指针。

其他相关命令：

  • ipcs: 查看系统中所有的IPC设施状态，包括消息队列、共享内存段和信号量。
  • ipcrm: 删除指定的IPC设施，比如信号量集。

基于循环队列的生产者和消费者模型

我们这里模拟实现一个基于循环队列的生产者和消费者模型，首先我们实现一个循环队列：

先把架子搭好：

#include<iostream>
#include<semaphore>
#include<pthread.h>
#include<cstring>
#include<vector>
#include<semaphore.h>
#include<unistd.h>


template<class T>
class CircleQueue
{
public:
    CircleQueue()
        :_size(10)
        ,_product_start(0)
        ,_consum_start(0)
    {

    }

    ~CircleQueue()
    {

    }



private:
};

现在，我们要分析一下，这里面的同步关系：

同步关系

我们这里清楚，生产者会消费一个空间生产一个产品，并往前走一步，并且生产者和消费者是指向一个空间：
在这里插入图片描述在这里插入图片描述消费者会消费一个产品，腾出一个空间资源，然后往前走一步：
在这里插入图片描述这个时候，我们可以分析出以下几条信息：

  1. 生产者一定先跑，因为一开始有空间资源，没有产品资源。
  2. 消费者一定比生产者跑的慢，因为消费者的速度是受生产者产出产品的速度决定的。
  3. 当空间资源被用完时，生产者停止生产，让消费者消费之后，腾出空间资源之后再继续生产。相反，如果没有产品资源，消费者阻塞，让生产者产出产品之后，再消费产品。
#include <iostream>
#include <semaphore>
#include <pthread.h>
#include <cstring>
#include <vector>
#include <semaphore.h>
#include <unistd.h>

// 定义一个泛型循环队列类，利用信号量实现线程安全的生产者消费者模型
template <class T>
class CircleQueue {
public:
    // 默认构造函数，初始化一个大小为10的循环队列
    CircleQueue()
        : _size(10), // 队列默认容量
          _product_start(0), // 生产者开始位置
          _consum_start(0) // 消费者开始位置
    {
        // 初始化空间信号量，初始值为队列大小，表示可用空间数量
        sem_init(&_sem_space, 0, _size);
        // 初始化数据信号量，初始值为0，表示当前没有可消费的数据
        sem_init(&_sem_data, 0, 0);
        // 初始化队列容器
        _queue.resize(_size);
    }

    // 带参数构造函数，允许用户自定义队列大小
    CircleQueue(int size)
        : _size(size), // 用户指定的队列容量
          _product_start(0),
          _consum_start(0)
    {
        sem_init(&_sem_space, 0, size); // 根据用户指定的大小初始化空间信号量
        sem_init(&_sem_data, 0, 0);
        _queue.resize(size);
    }

    // 析构函数，释放信号量资源
    ~CircleQueue() {
        sem_destroy(&_sem_space);
        sem_destroy(&_sem_data);
    }

    // 生产者方法，向队列中添加数据
    void Push(const T& data) {
        // 在尝试放入数据前，先等待确保有空闲空间
        sem_wait(&_sem_space);
        // 将数据放入队列的下一个生产位置
        _queue[_product_start] = data;
        // 更新生产者位置，并对索引取模以实现循环
        _product_start = (_product_start + 1) % _size;
        // 数据放入后，释放数据信号量，通知消费者有新数据可取
        sem_post(&_sem_data);
    }

    // 消费者方法，从队列中取出数据
    void Pop(T* out) {
        // 等待直到有数据可消费
        sem_wait(&_sem_data);
        // 从队列的下一个消费位置取出数据
        *out = _queue[_consum_start];
        // 更新消费者位置，并对索引取模实现循环
        _consum_start = (_consum_start + 1) % _size;
        // 数据取出后，释放空间信号量，表明队列中有更多空间可填充
        sem_post(&_sem_space);
    }

private:
    // 循环队列的底层数据结构
    std::vector<T> _queue;
    int _size; // 队列的最大容量

    // 生产者和消费者的当前位置索引
    int _product_start;
    int _consum_start;

    // 信号量用于同步控制
    sem_t _sem_space; // 控制队列中的空闲空间
    sem_t _sem_data; // 控制队列中的有效数据量
};

这段代码实现了一个基于信号量的线程安全循环队列模板类。它支持生产者线程向队列中添加元素（通过Push方法），同时允许消费者线程从队列中取出元素（通过Pop方法）。通过使用两个信号量——_sem_space 和 _sem_data——分别管理队列的可用空间和有效数据量，确保了多线程环境下的正确同步与互斥。

基于这个，我们实现一下整体的代码：

#include"CircleQueue.hpp"
#include<time.h>

void* product(void* args)
{
    CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);

    while(true)
    {
        //生产数据
        int randomdata = rand() % 10 + 1;
        cq->Push(randomdata);
        std::cout << "Producter has product a number: " << randomdata <<
        std::endl; 
        
    }

    return nullptr;
}

void* consum(void* args)
{
    CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);
    while(true)
    {
        //拿出数据
        int outnumber = 0;
        cq->Pop(&outnumber);
        std::cout << "Consum gets a number: " << outnumber <<
        std::endl; 
        sleep(1);
    }

    return nullptr;
}

int main()
{
    srand(time(0));
    //创建线程
    pthread_t tid_product,tid_consum;
    
    CircleQueue<int>*cq = new CircleQueue<int>();
    //生产者
    pthread_create(&tid_product,nullptr,product,cq);

    //消费者
    pthread_create(&tid_consum,nullptr,consum,cq);

    pthread_join(tid_product,nullptr);
    pthread_join(tid_consum,nullptr);
}

在这里插入图片描述
大家可以调整一下生产者或者消费者的速度，看看情况怎么样。

多生产多消费

这里注意一下，这里和互斥锁的情况有点不一样：

我们用一个通俗的例子来解释：

假设有一天，你和你的好朋友（一共8个人），想去电影院看电影：
在这里插入图片描述
你们到售票机哪里去买票，此时电影院的座位很充足，所以你们都买到票了。
在这里插入图片描述但是一看座位号，发现大家全都是1号座位

在这里插入图片描述
这就很尴尬了，这个场景可以类比到我们上面的代码中，8个线程通过了信号量，但是都在往一个位置位置放东西，这样不行，所以我们得出位置是每个人独有的，一人一份，如果自己拥有，别人就不能拥有，所以为了保证每一个位置为一人独有所以我们要给每个位置上锁（电影院的座位）

如果有点绕，咋们来复盘一下：

  1. 电影院有很多位置，所以，我们多人可以都得到属于自己的位置（类比我们的循环队列）
  2. 为了保证我们的位置是独一无二属于自己，我们要给自己的位置上锁，保证只有自己可以坐这个座位。（类比循环队列中的下标）

解决完上面的问题，我们现在要做的，就是还要两把锁，一个保证生产的时候，放入时候的位子只属于一个生产者进程，另一把锁保证从一个位置里面拿产品的时候只属于一个消费者进程：

#include <iostream>
#include <semaphore>
#include <pthread.h>
#include <cstring>
#include <vector>
#include <semaphore.h>
#include <unistd.h>

// 定义一个泛型循环队列类，结合信号量与互斥锁实现线程安全的生产者消费者模型
template <class T>
class CircleQueue {
public:
    // 默认构造函数，初始化一个大小为10的循环队列，并初始化信号量与互斥锁
    CircleQueue()
        : _size(10), // 队列默认容量
          _product_start(0), // 生产者开始位置
          _consum_start(0) // 消费者开始位置
    {
        sem_init(&_sem_space, 0, _size); // 初始化空间信号量，初始值为队列大小
        sem_init(&_sem_data, 0, 0); // 初始化数据信号量，初始值为0
        pthread_mutex_init(&_p_mutex, nullptr); // 初始化生产者互斥锁
        pthread_mutex_init(&_c_mutex, nullptr); // 初始化消费者互斥锁
        _queue.resize(_size); // 初始化队列向量
    }

    // 带参数构造函数，允许自定义队列大小
    CircleQueue(int size)
        : _size(size),
          _product_start(0),
          _consum_start(0)
    {
        sem_init(&_sem_space, 0, size);
        sem_init(&_sem_data, 0, 0);
        pthread_mutex_init(&_p_mutex, nullptr);
        pthread_mutex_init(&_c_mutex, nullptr);
        _queue.resize(size);
    }

    // 析构函数，释放信号量与互斥锁资源
    ~CircleQueue() {
        sem_destroy(&_sem_space);
        sem_destroy(&_sem_data);
        pthread_mutex_destroy(&_p_mutex);
        pthread_mutex_destroy(&_c_mutex);
    }

    // 生产者方法，向队列中添加数据
    void Push(const T& data) {
        // 确保有足够的空间再进行生产
        sem_wait(&_sem_space);
        // 使用互斥锁保护生产过程，防止与其它生产者并发冲突
        pthread_mutex_lock(&_p_mutex);
        _queue[_product_start] = data; // 添加数据
        _product_start = (_product_start + 1) % _size; // 更新生产者位置
        pthread_mutex_unlock(&_p_mutex); // 释放锁
        sem_post(&_sem_data); // 数据添加完毕，释放数据信号量
    }

    // 消费者方法，从队列中取出数据
    void Pop(T* out) {
        // 确保有数据可消费
        sem_wait(&_sem_data);
        // 使用互斥锁保护消费过程
        pthread_mutex_lock(&_c_mutex);
        *out = _queue[_consum_start]; // 取出数据
        _consum_start = (_consum_start + 1) % _size; // 更新消费者位置
        pthread_mutex_unlock(&_c_mutex); // 释放锁
        sem_post(&_sem_space); // 释放空间信号量
    }

private:
    // 循环队列的底层数据结构
    std::vector<T> _queue;
    int _size; // 队列的最大容量

    // 生产者和消费者的当前位置索引
    int _product_start;
    int _consum_start;

    // 同步控制工具
    sem_t _sem_space; // 控制队列中的空闲空间
    sem_t _sem_data; // 控制队列中的有效数据量

    // 互斥锁用于保护队列访问的原子性
    pthread_mutex_t _p_mutex; // 生产者使用的互斥锁
    pthread_mutex_t _c_mutex; // 消费者使用的互斥锁
};

这里打印的时候，由于屏幕也是公共资源，我这里加锁，是保证打印的时候，只有生产者或者消费者打印信息：

#include"CircleQueue.hpp"
#include<time.h>

pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER;

void* product(void* args)
{
    CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);

    while(true)
    {
        //生产数据
        int randomdata = rand() % 10 + 1;
        cq->Push(randomdata);


        pthread_mutex_lock(&global_mutex);
        std::cout << "Producter has product a number: " << randomdata <<
        std::endl; 
        pthread_mutex_unlock(&global_mutex);
    }

    return nullptr;
}

void* consum(void* args)
{
    CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);
    while(true)
    {
        //拿出数据
        int outnumber = 0;
        cq->Pop(&outnumber);

        pthread_mutex_lock(&global_mutex);
        std::cout << "Consum gets a number: " << outnumber <<
        std::endl; 
        pthread_mutex_unlock(&global_mutex);
        sleep(1);
    }

    return nullptr;
}

int main()
{
    srand(time(0));
    //创建线程
    pthread_t tid_product[8],tid_consum[8];
    
    CircleQueue<int>*cq = new CircleQueue<int>();

    //生产者
    for(int i = 0; i < 8; i++)
    {
        pthread_create(&tid_product[i],nullptr,product,cq);
    }
    

    //消费者
    for(int i = 0; i < 8; i++)
    {
        pthread_create(&tid_consum[i],nullptr,consum,cq);
    }
 
    for(int i = 0; i < 8; i++)
    {
        pthread_join(tid_product[i],nullptr);
    }
    
    for(int i = 0; i < 8; i++)
    {
        pthread_join(tid_consum[i],nullptr);
    }
    
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/640118.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

软考--软件设计师-刷题总结

软考--软件设计师-刷题总结

一、数据结构 贪心算法 归并排序将问题先分解、再处理、再合并的方式采用了分治法的思想 分治法&#xff1a;将一个大问题分成若干个小问题 希尔排序&#xff1a; 定义一个 i 变量指向这一组的第二个数据&#xff0c;定义一个 j 变量指向 i - gap 的位置。 将 i 下标的值放到…
阅读更多...
使用python不改变格式的情况下批量替换word里面的内容

使用python不改变格式的情况下批量替换word里面的内容

需要使用如$name,${id}这样的模板 import os import io from python_docx_replace import docx_replace,docx_get_keys from docx import Document from random import randrange student_list1,张三,2202330301 2,李四,2202330302 3,王五,2202330303 review["思路清晰、…
阅读更多...
产品数据特性驱动设计

产品数据特性驱动设计

一、什么是数据特性 一个产品在宏观的视角下，是不同功能模块的有机组合；在微观的视角上，是千丝万缕的数据连接。 基于模块化设计思想，对产品进行业务化梳理，对业务进行模块化拆分出功能模块，功能模块就是产品的“逻辑”，而功能中的数据就是“特性”。 业务：比较固定…
阅读更多...
防范TOCTOU竞态条件攻击

防范TOCTOU竞态条件攻击

防范TOCTOU竞态条件攻击 在软件开发过程中&#xff0c;我们常常会遇到需要在使用资源之前检查其状态的情况。然而&#xff0c;如果资源的状态在检查和使用之间发生了变化&#xff0c;那么检查的结果可能会失效&#xff0c;导致软件在资源处于非正常状态时执行无效操作。这种时…
阅读更多...
如何提升百度小程序的收录？百度小程序如何做优化？

如何提升百度小程序的收录？百度小程序如何做优化？

​ 如何通过百度小程序获得更多的自然流量&#xff1f;这是做百度小程序肯定要考虑的问题&#xff0c;做百度小程序的目的就是想借助百度生态&#xff0c;做相应的关键词给自己的小程序引流&#xff0c;如何把流量给做起来呢&#xff0c;接下来我从不同的方面给大家进行分析讲解…
阅读更多...
[牛客网]——C语言刷题day5

[牛客网]——C语言刷题day5

答案&#xff1a;D 解析&#xff1a;因为两个指针都指向的字符串常量&#xff0c;不能被重新赋值&#xff0c;*p*q是错误的 在C语言中&#xff0c;赋值语句的返回值都是所赋的值&#xff0c;所以才会有连续赋值的语句&#xff0c;例如ab10&#xff0c;因此&#xff0c;这里的i…
阅读更多...
Github 2024-05-25 Rust开源项目日报Top10

Github 2024-05-25 Rust开源项目日报Top10

根据Github Trendings的统计，今日(2024-05-25统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下： 开发语言项目数量Rust项目10Svelte项目1TypeScript项目1Python项目1Go项目1Dart项目1RustDesk: 用Rust编写的开源远程桌面软件 创建周期：1218 天开发语言：Rust…
阅读更多...
sw套合样条曲线

sw套合样条曲线

套合样条曲线,可以变成一条曲线,然后可以进行分段
阅读更多...
springcloud 之 Ribbon Hystrix Feign bus 动态修改配置

springcloud 之 Ribbon Hystrix Feign bus 动态修改配置

Ribbon 是微服务架构图中负责负载均衡的 组件。 BeanLoadBalancedpublic RestTemplate getRestTemplate() {return new RestTemplate();}测试如下&#xff1a; //微服务方式 Ribbon方式GetMapping("ribbon/{name}")public String RibbonTest(PathVariable String nam…
阅读更多...
SSRF服务端请求伪造漏洞原理与修复及靶场实践

SSRF服务端请求伪造漏洞原理与修复及靶场实践

SSRF服务端请求伪造漏洞原理与修复及靶场实践 SSRF漏洞原理与检测 SSRF&#xff08;Server-Side Request Forgery&#xff0c;服务器端请求伪造&#xff09;漏洞是一种因为服务端提供了远程访问服务&#xff0c;而并未对请求目标进行限制或限制不严格而引起的安全漏洞&#x…
阅读更多...
极空间部署本地最强私有化PDF工具箱『Stirling-PDF』

极空间部署本地最强私有化PDF工具箱『Stirling-PDF』

极空间部署本地最强私有化PDF工具箱『Stirling-PDF』 哈喽小伙伴们好&#xff0c;我是Stark-C~ 关注我的粉丝应该知道&#xff0c;我在前几天教大家怎么在NAS上部署本地最强私有化PDF工具箱『Stirling-PDF』&#xff1a; &#x1f53a;评论区好几位小伙伴都提到了极空间的部署…
阅读更多...
【免费Web系列】大家好 ,今天是Web课程的第六天点赞收藏关注,持续更新作品 !

【免费Web系列】大家好 ,今天是Web课程的第六天点赞收藏关注,持续更新作品 !

这是Web第一天的课程大家可以传送过去学习 http://t.csdnimg.cn/K547r 后端Web实战(IOCDI) 前言 Web开发的基础知识 &#xff0c;包括 Tomcat、Servlet、HTTP协议等&#xff0c;我们都已经学习完毕了&#xff0c;那接下来&#xff0c;我们就要进入Web开发的实战篇。在实战篇中…
阅读更多...
基于自抗扰控制器和线性误差反馈控制律(ADRC-LSEF)的控制系统simulink建模与仿真

基于自抗扰控制器和线性误差反馈控制律(ADRC-LSEF)的控制系统simulink建模与仿真

目录 1.课题概述 2.系统仿真结果 3.核心程序与模型 4.系统原理简介 4.1 ADRC原理 4.2 线性误差反馈控制律(LSEF) 4.3 ADRC-LSEF融合系统 5.完整工程文件 1.课题概述 基于自抗扰控制器和线性误差反馈控制律(ADRC-LSEF)的控制系统simulink建模与仿真。 2.系统仿真结果 …
阅读更多...
[Unity报错] The type or namespace name ‘Newtonsoft‘ could not be found

[Unity报错] The type or namespace name ‘Newtonsoft‘ could not be found

简介 Unity在跑别人的代码时&#xff0c;控制台报了以下错误 The type or namespace name Newtonsoft could not be found 鉴于这块资料较少&#xff0c;写一下教程帮助后来者。 报错的原因主要是因为缺少Newtonsoft.json这个包&#xff0c;导致Unity在using该库时出现错误。…
阅读更多...
【Vue3】封装axios请求（cli和vite）

【Vue3】封装axios请求（cli和vite）

原文作者&#xff1a;我辈李想 版权声明&#xff1a;文章原创&#xff0c;转载时请务必加上原文超链接、作者信息和本声明。 Vue 【Vue3】env环境变量的配置和使用&#xff08;区分cli和vite&#xff09; 文章目录 Vue前言一、常见用法二、vue3cli封装接口1..env配置2..dev(开…
阅读更多...
LuatOS-iRTU

LuatOS-iRTU

DTU 英文全称为Data Transfer Unit&#xff0c;表示数据传输单元。 是专门用于将串口数据转为IP数据或将I[数据转换为串口数据&#xff0c;通过无线通信网络进行传送的无线终端设备。 业务逻辑包括数据采集上报&#xff1a; 传感器采集数据发送给单片机&#xff0c;单片机由串…
阅读更多...
数据库常用命令（1）

数据库常用命令（1）

DML 1.添加数据&#xff08;insert into&#xff09; insert into 表名 values (值1&#xff0c;值2....); 表示成功运行&#xff1a; 2.修改数据&#xff08;update&#xff09; update 表名 set 字段名1值1&#xff0c;字段名2值2.....【where条件】 3.删除数据&#xff0…
阅读更多...
STM32使用旋转编码开关

STM32使用旋转编码开关

一、旋转编码开关如何工作 编码器内部有一个开槽圆盘&#xff0c;连接到公共接地引脚 C。它还具有两个接触针 A 和 B&#xff0c;如下所示。 当您转动旋钮时&#xff0c;A 和 B 按照特定顺序与公共接地引脚 C 接触&#xff0c;具体顺序取决于转动旋钮的方向。 当它们与公共地接…
阅读更多...
23种设计模式之一————外观模式详细介绍与讲解

23种设计模式之一————外观模式详细介绍与讲解

外观模式详细讲解 一、概念二、 外观模式结构核心思想及解释模式的UML类图模式角色应用场景模式优点模式缺点 三、实例演示图示代码展示运行结果 一、概念 外观模式&#xff08;Facade Pattern&#xff09;是一种结构型设计模式&#xff0c;它提供了一个统一的接口&#xff0c…
阅读更多...
详细分析Vue按钮间距的优化方式（附Demo）

详细分析Vue按钮间距的优化方式（附Demo）

目录 前言1. 按钮间距2. 垂直间距 前言 正常间距如下&#xff1a; 其Demo如下&#xff1a; <el-table-column label"操作" align"center"><template #default"scope"><el-buttonlinktype"primary"click"openFor…
阅读更多...
最新文章

Copyright @ 2022~2023