Linux--信号量

最新推荐文章于 2024-10-16 22:28:24 发布

momo小菜pa

最新推荐文章于 2024-10-16 22:28:24 发布

阅读量1.1k

点赞数 15

分类专栏： Linux学习文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/2301_76618602/article/details/140520200

版权

Linux学习专栏收录该内容

46 篇文章 1 订阅

订阅专栏

1.概念

信号量是什么？

想象一下你有一个小小的计数器，这个计数器不是用来数人数或者物品数量的，而是用来控制“访问权”的。这个特殊的计数器，我们就叫它“信号量”。

信号量的作用是什么？

信号量的主要作用是帮助多个“人”（我们可以把这里的“人”想象成进程、线程或者任何需要同步的实体）在争夺同一个“资源”（比如打印机、数据库连接、共享内存等）时保持秩序，避免混乱。

之前我们知道被多个执行流同时访问的公共资源叫做临界资源，而临界资源不保护的话会造成数据不一性的问题。
们用互斥锁保护临界资源是把这个临界资源当做一个整体，只能让1个执行流访问临界资源。现在我们把临界资源分割成多个区域，当多个执行流访问不同的区域，此时不会出现数据不一性的问题了。

每个执行流先申请信号量，申请到信号量后同时访问临界资源，访问完后释放信号量。

信号量怎么工作？

信号量有两个关键操作，我们称之为“P操作”和“V操作”。

P操作（等待/申请）：当你想要使用一个资源时，你会走到信号量面前，告诉它你想要访问那个资源。信号量会看看它的小计数器上写着多少。如果计数器大于0，说明还有资源可用，它就会把计数器减1，然后让你进去使用资源。如果计数器是0，说明资源都被别人占用了，它会让你在一边等着，直到有人释放资源。

V操作（释放/通知）：当你用完资源后，你会再次走到信号量面前，告诉它你已经用完了。信号量就会把它的计数器加1，表示又多了一个资源。然后，如果有人在等这个资源（因为之前的P操作被挡住了），信号量就会叫醒其中一个人，让他进去使用资源。

2.认识接口

sem_init 函数是用于初始化一个未命名的信号量（semaphore）的函数。是线程间或进程间同步的一种机制。通过信号量，程序可以控制对共享资源的访问，确保在同一时间内只有一个线程（或进程）能够访问某个特定的资源。

参数

sem：指向要初始化的信号量对象的指针。
pshared：控制信号量的作用域。如果pshared的值非0，则信号量在进程间共享；如果为0，则信号量仅在调用进程内的线程间共享。
value：信号量的初始值。这个值必须是非负的。

返回值

成功时，sem_init 返回0。
失败时，返回-1，并设置errno以指示错误

sem_destroy函数的作用是释放与信号量相关联的资源，确保系统资源的正确回收。

参数

sem：指向要销毁的信号量对象的指针。

返回值

成功时，sem_destroy 返回 0。
失败时，返回 -1，并设置 errno 以指示错误。可能的错误包括 EINVAL，表示传入的信号量不是一个有效的信号量。

sem_wait函数是信号量同步机制中的关键部分，用于实现线程或进程间的同步。

该函数用于信号量的P操作，从信号量的值中减去1，如果信号量的值变为0，则当前线程将被阻塞，直到信号量的值被其他线程通过 sem_post 增加。

参数

sem：指向要操作的信号量对象的指针。

返回值

成功时返回0。
失败时返回-1，并设置errno以指示错误。

sem_post函数用于信号量的V操作，主要作用是给信号量的值加上一个“1”，并可能唤醒一个或多个在该信号量上等待的线程。

参数

sem：指向要操作的信号量的指针。

功能

增加信号量值：sem_post函数将信号量的值增加1。
唤醒等待线程：如果有线程因为调用sem_wait函数而在该信号量上等待（即信号量的值为0且线程被阻塞），那么sem_post函数可能会唤醒其中一个等待的线程。具体唤醒哪个线程取决于操作系统的线程调度策略。

返回值

成功时，sem_post返回0。
失败时，返回-1，并设置errno以指示错误。可能的错误包括EINVAL，表示传入的信号量不是一个有效的信号量。

3.理论加代码

3.1问题背景

如何基于环形队列实现生产消费模型：

        环形结构起始状态和结束状态都是一样的，不好判断为空或者为满，所以可以通过加计数器或者标记位来判断满或者空。另外也可以预留一个空的位置，作为满的状态

比如消费者（head）指向头，生产者（end）指向尾。

当head和end 指向一个位置时：

1.队列为空，让谁先访问？当然只能让生产者先生产。

2.队列满了，让谁再访问？当然只能让消费者来消费

这其实就满足了一定顺序性了（同步），而且是满足了互斥特定的

head和end指向不同的位置：

队列不为空&&队列不为满--此时生产和消费同时进行！因为head和end方位的是同一块资源的不同位置，多线程当然可以并发访问的了。

        基于以上两种情况，我们就可以让线程再局部上体现互斥和同步的特点，在宏观上体现出并发了。

结论：

a.不让生产者把消费者套一个圈。

b.不能让消费者，超过生产者

以上条件，用信号量（用于做互斥与同步的）就能满足了。

3.2解决方案

对于以上问题，消费者最关心的是数据资源（取数据）。对于生产者来说，最关心的就是空间资源（放数据）。信号量就是描述资源数量的。因此我们可以定义两个信号量：

sem_t data_sem=0，初始化肯定是0(数据资源），sem_t space_sem=N（空间资源）。

        生产者p(space_sem)申请空间资源--，生产动作v(data_sem)数据资源++，生产者申请到空间了，但数据还是在那块空间，当然v的是数据的信号量。
        消费者p(data_sem)申请数据资源--,消费动作v(space_sem)空间资源++，消费者把数据拿走了只留下空间了，当然v的是空间的信号量。

一开始，data资源为0，也就是为空情况，消费线程和生产线程都来了，消费线程是注定要被挂起。deat资源为N，也就是为满的情况，消费线程和生产线程都来了，生产线程主动要被挂起。这就完成了互斥（理论上互斥）

data和space达到动态平衡时，消费线程和生产线程都能进来，他们的两个下标也不会指向同一个位置，这就达到了并发的效果。

因为data和space资源最大为N，这注定了生产线程不能一直无脑生产最大为N，消费者不能无脑消费，最大为N。

3.3代码实现

RingQueue.hpp：
#pragma once

#include <iostream>
#include <vector>
#include <string>
#include <pthread.h>
#include <semaphore.h>

template <typename T>
class RingQueue
{
private:
    void P(sem_t &s)
    {
        sem_wait(&s);//对信号量--
    }
    void V(sem_t &s)
    {
        sem_post(&s);//对信号量++
    }
public:
    RingQueue(int max_cap)
        : _ringqueue(max_cap), _max_cap(max_cap), _c_step(0), _p_step(0)
    {
        sem_init(&_data_sem, 0, 0);
        sem_init(&_space_sem, 0, max_cap);

        pthread_mutex_init(&_c_mutex, nullptr);
        pthread_mutex_init(&_p_mutex, nullptr);
    }
    void Push(const T &in) //生产者
    {
        
        P(_space_sem); 
        pthread_mutex_lock(&_p_mutex); //?
        _ringqueue[_p_step] = in;//生产的位置
        _p_step++;
        _p_step %= _max_cap;//维持环状
        pthread_mutex_unlock(&_p_mutex);
        V(_data_sem);//数据资源多了一个
    }
    void Pop(T *out) // 消费
    {
        P(_data_sem);//申请数据资源
        pthread_mutex_lock(&_c_mutex); //?
        *out = _ringqueue[_c_step];//在消费者下标进行消费
        _c_step++;
        _c_step %= _max_cap;
        pthread_mutex_unlock(&_c_mutex);
        V(_space_sem);//数据取走，空间空出来，归还空间
    }
    ~RingQueue()
    {
        sem_destroy(&_data_sem);
        sem_destroy(&_space_sem);

        pthread_mutex_destroy(&_c_mutex);
        pthread_mutex_destroy(&_p_mutex);
    }
private:
    std::vector<T> _ringqueue;//vector模拟的环形队列结构
    int _max_cap;//容量

    int _c_step;//生产者下标
    int _p_step;//消费者下标

    sem_t _data_sem; // 消费者关心
    sem_t _space_sem; // 生产者关心

    pthread_mutex_t _c_mutex;//生产者互斥锁
    pthread_mutex_t _p_mutex;//消费者互斥锁
};
细节：

1.为了完成多生产和多消费的模型，消费者和生产者的同步和互斥问题我们的消费队列已经解决了。那么我们就要维护生产者和生产者的互斥关系，还有消费者和消费者之间的互斥关系。由于环形队列的下标也是属于临界资源的，如果不维持关系内部的互斥关系，是一定会破坏环形队列结构的。所以势必要引入生产者互斥锁和消费者互斥锁。

2.先加锁好还是先申请获取信号量好呢？

先申请信号量好，所有线程先瓜分好信号量，在其它线程进行等待锁的时候，此时资源已经申请好了，这样提高了解决问题的实际效率。

3.信号量这里，对资源进行使用，申请，为什么不判断一下条件是否满足？

信号量本身就是判断条件！信号量：是一个计数器，是资源的预订机制。预订：在外部，可以不判断资源是否满足，就可以知道内部资源的情况！

信号量原理：一元信号量（或二元信号量）主要用于实现资源的互斥访问。当一个线程（或进程）获取了信号量（将其值从1减为0），它便获得了对某个共享资源的独占访问权，其他试图获取该信号量的线程将被阻塞，直到信号量被释放（其值从0加回1）。

信号量对公共资源使用时可以整体使用，也可以不整体使用。整体使用就是把整个资源看作一份。当看整体的时候，当二元信号量的值为1时，表示资源未被占用，线程可以获取信号量并进入临界区；当信号量的值为0时，表示资源已被占用，其他线程必须等待。那么这就等同于互斥锁了。

Task.hpp:
#pragma once

#include<iostream>


class Task
{
public:
    Task()
    {
    }
    Task(int x, int y) : _x(x), _y(y)
    {
    }
    void Excute()
    {
        _result = _x + _y;
    }
    void operator ()()
    {
        Excute();
    }
    std::string debug()
    {
        std::string msg = std::to_string(_x) + "+" + std::to_string(_y) + "=?";
        return msg;
    }
    std::string result()
    {
        std::string msg = std::to_string(_x) + "+" + std::to_string(_y) + "=" + std::to_string(_result);
        return msg;
    }

private:
    int _x;
    int _y;
    int _result;
};
main.cc:多生产者生产，多消费者消费
#include "RingQueue.hpp"
#include "Task.hpp"
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <ctime>

void *Consumer(void*args)
{
    RingQueue<Task> *rq = static_cast<RingQueue<Task> *>(args);
    while(true)
    {
        Task t;
        // 1. 消费
        rq->Pop(&t);

        // 2. 处理数据
        t();
        std::cout << "Consumer-> " << t.result() << std::endl;
    }
}
void *Productor(void*args)
{
    RingQueue<Task> *rq = static_cast<RingQueue<Task> *>(args);

    while(true)
    {
        sleep(1);

        // 1. 构造数据
        int x = rand() % 10 + 1; //[1, 10]
        usleep(x*1000);
        int y = rand() % 10 + 1;
        Task t(x, y);

        // 2. 生产
        rq->Push(t);

        std::cout << "Productor -> " << t.debug() << std::endl;
    }
}

int main()
{
    srand(time(nullptr) ^ getpid());
    RingQueue<Task> *rq = new RingQueue<Task>(5);
    // 单单
    pthread_t c1, c2, p1, p2, p3;
    pthread_create(&c1, nullptr, Consumer, rq);
    pthread_create(&c2, nullptr, Consumer, rq);
    pthread_create(&p1, nullptr, Productor, rq);
    pthread_create(&p2, nullptr, Productor, rq);
    pthread_create(&p3, nullptr, Productor, rq);


    pthread_join(c1, nullptr);
    pthread_join(c2, nullptr);
    pthread_join(p1, nullptr);
    pthread_join(p2, nullptr);
    pthread_join(p3, nullptr);
    return 0;
}