【Linux】POSIX信号量

前言：

这篇文章我们来讲讲Linux——POSIX信号量：

1. 回顾信号量
2. POSIX信号量接口
3. 基于环形队列的生产者消费者模型

个人简介：努力学习ing
个人专栏：Linux
CSDN主页 愚润求学
其他专栏：C++学习笔记，C语言入门基础，python入门基础，C++刷题专栏

---

一、回顾信号量

之前，我们讲述过System V版本的信号量（用于进程）
POSIX版本的信号量（可用于线程），如果要用于进程可以强转，比如把共享资源的前面一部分内容直接强转成POSIX版本的信号量（相当于顶替定义操作了）

• 信号是一个计数器，用来描述一大片共享资源中可用资源的数量（我们把这一大片共享资源给划分了）
• 信号量的本质是对资源的预订机制
  • 线程要获得资源，要先 P 操作 （等待操作，计数器--，申请信号量）
  • 使用完资源以后，要 V 操作 （发布操作，计数器++，释放信号量）
• P 操作和 V 操作本身是原子的
• 如果当前信号量不够了（P的时候，信号量为0），则该线程会被加入到信号量的等待队列中。（直到有线程 V 操作把信号量给放出来了）

二、POSIX信号量接口

1. 初始化和销毁

初始化

#include 
int sem_init(sem_t *sem, int pshared, unsigned int value);

• sem_t信号量的类型
• sem：要初始化的信号量
• pshared：零表示线程间共享，非零表示进程间共享（传0就行）
• value：信号量初始值
• 返回值：成功，零，失败，非零

销毁

int sem_destroy(sem_t *sem);

2. 等待和发布

等待

int sem_wait(sem_t *sem);  // P 操作

• 当信号量为0，线程就会被放到信号量等待队列里面等
• 这个操作是原子的
• 如果为负数就不能访问临界资源，也就是说，在访问临界资源之前，信号量已经对“条件”进行了判断（相当于互斥锁的while）

发布

int sem_post(sem_t *sem); // V 操作

三、基于环形队列的生产者消费者模型

1. 基本实现

1.1 思路

问题描述

• 生产者往空的位置上生产，消费者消费不为空的位置。
• 队列为空：生产者先生产（消费者不能超过生产者）
• 队列为满：消费者先消费（生产者不能套消费者一圈以上）

问题抽象

• 生产者只关注空盘子
• 消费者只关注非空盘子
• 两者在同一位置时（为空 / 为满），两者才需要同步和互斥
• 不在同一位置时，生产者和消费者之间行为独立

模型特点

• 3 个关系（基本不变）
  • 生产与生产：互斥（单生产单消费时退化，只有一个生产者就没有互斥）
  • 消费与消费：互斥
  • 生产与消费
    • 不在同一位置时：互不影响（无关系）
    • 在同一个位置时：互斥 + 同步
• 2 个角色：生产者和消费者线程
• 1 个交易场所（环形队列）

实现

• 用二元信号量（且这两个信号量之间有关联）
  • 一个描述空盘子数量
  • 一个描述非空盘子的数量
• 用vector来模拟环形队列，生产和消费往vector对应下标里进行

1.2 实现及运行

实现

代码实现

RingQueue.hpp文件：

#include 
#include 
#include 
#include 

using namespace std;

template <typename T>
class RingQueue
{
public:
    RingQueue(int size)
        :_cap(size),
        _p_step(0),
        _c_step(0)
    {
        _ringqueue.resize(size);
        sem_init(&_empty_sem, 0, size);
        sem_init(&_noempty_sem, 0, 0);  // 初始时，没有非空位置
        pthread_mutex_init(&_mutex_p, nullptr);
        pthread_mutex_init(&_mutex_c, nullptr);
    }

    ~RingQueue() 
    {
        sem_destroy(&_empty_sem);
        sem_destroy(&_noempty_sem);
        pthread_mutex_destroy(&_mutex_p);
        pthread_mutex_destroy(&_mutex_c);
    }

    void Push(const T &data) 
    {
        // 1. 申请信号量
        sem_wait(&_empty_sem); // 如果失败就阻塞
        // 多生产之间 要加锁
        pthread_mutex_lock(&_mutex_p);
        // 2. 生产
        _ringqueue[_p_step] = data;
        // 3. 生产者位置改变（并维护环形队列）
        _p_step = (_p_step + 1) % _cap;
        // 4. 改变 _noempty_sem，通知消费者
        sem_post(&_noempty_sem);
        // 解锁
        pthread_mutex_unlock(&_mutex_p);
    }
    void Pop(T* data) 
    {
        // 1. 申请信号量
        sem_wait(&_noempty_sem); // 如果失败就阻塞
        // 多消费者之间 要加锁
        pthread_mutex_lock(&_mutex_c);
        // 2. 消费
        *data = _ringqueue[_c_step];
        // 3. 消费者位置改变（并维护环形队列）
        _c_step = (_c_step + 1) % _cap;
        // 4. 改变 _noempty_sem，通知生产者
        sem_post(&_empty_sem);
        // 解锁
        pthread_mutex_unlock(&_mutex_c);
    }

private:
    vector<T> _ringqueue;
    int _cap;
    sem_t _empty_sem; // 描述空位置
    sem_t _noempty_sem;

    int _p_step; // 生产者所在位置
    int _c_step;

    // 多生产，多消费需要加锁，维护生产者和生产者，消费者和消费者之间的互斥关系
    pthread_mutex_t _mutex_p;
    pthread_mutex_t _mutex_c;
};

Main.cpp文件

#include "RingQueue.hpp"
#include 
#include 

int num = 1;

void* Pro(void* args)
{
    RingQueue<int>* p = static_cast<RingQueue<int>*>(args);
    while(true)
    {
        // sleep(2);
        p->Push(num);
        cout << "生产了一个任务: " << num <<endl;
        num++;
    }
}

void* Com(void* args)
{
    RingQueue<int>* p = static_cast<RingQueue<int>*>(args);
    while(true)
    {
        sleep(2);
        int ret;
        p->Pop(&ret);
        cout << "消费了一个任务: " << ret << endl;
    }
}


int main()
{
    int num = 0;
    RingQueue<int> super(5);
    // 单生产，单消费
    // pthread_t p[1], c[1];

    // pthread_create(&p[0], nullptr, Pro, &super);
    // pthread_create(&c[0], nullptr, Com, &super);

    // pthread_join(p[0], nullptr);
    // pthread_join(c[0], nullptr);

    // 多多
    pthread_t p[3], c[2];

    pthread_create(&p[0], nullptr, Pro, &super);
    pthread_create(&p[1], nullptr, Pro, &super);
    pthread_create(&p[2], nullptr, Pro, &super);
    pthread_create(&c[0], nullptr, Com, &super);
    pthread_create(&c[1], nullptr, Com, &super);

    pthread_join(p[0], nullptr);
    pthread_join(p[1], nullptr);
    pthread_join(p[2], nullptr);
    pthread_join(c[0], nullptr);
    pthread_join(c[1], nullptr);
}

运行

运行结果：
单生产单消费，且消费更快，则：生产一个消费一个

cout输出到屏幕上也有并发问题。

多生产，多消费（生产慢，消费快）：

对全局变量num的++操作不是原子的，也会有并发问题。
但是我们基本可以看出来消费的都是旧任务，生产的是新任务。

2. 细节解刨

2.1 多多模型的加锁

多多模型相比单单模型，缺少的就是3个关系中的前两个
多多模型，加锁的位置

• 在申请信号量之前和之后加都可以，但是在之后加效率更高
• 因为申请信号量也是原子操作，多个线程可以先分配好信号量，然后再去竞争锁。
• 如果先申请锁的话，那么每次只能把信号量分给一个线程。

2.2 对比互斥锁 + 条件变量实现的模型

互斥锁 + 条件变量

• 互斥锁 + 条件变量的实现，用在当资源作为整体使用的时候
  • 我们使用queue作为交易场所，但是queue不能同时往多个地方入队，所以只能整体使用

信号量

• 而信号量可以用于：当资源整体能被划分成多个小资源，且小资源可以同时访问的场景
  • 如果资源数量size为 1，则这时候也就退化成了互斥锁 + 条件变量模型

进一步封装

• 当然我们也可以把库的信号量 / 锁封装起来，让代码更优雅
• 然后把访问临界区的代码用{}扩起来，在{}内定义的变量声明周期随{}

---

我的分享也就到此结束啦
要是我的分享也能对你的学习起到帮助，那简直是太酷啦！
若有不足，还请大家多多指正，我们一起学习交流！
公主，王子：点赞→收藏⭐→关注
感谢大家的观看和支持！祝大家都能得偿所愿，天天开心！！！