当前位置：首页 > news >正文

【Linux】POSIX信号量

news 2025/7/27 6:53:51

📝前言：

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

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

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

一、回顾信号量
二、POSIX信号量接口
- 1. 初始化和销毁
- 2. 等待和发布
三、基于环形队列的生产者消费者模型
- 1. 基本实现
- - 1.1 思路
  - 1.2 实现及运行
  - - 实现
    - 运行
- 2. 细节解刨
- - 2.1 多多模型的加锁
  - 2.2 对比互斥锁 + 条件变量实现的模型

一、回顾信号量

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

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

二、POSIX信号量接口

1. 初始化和销毁

初始化

#include <semaphore.h>
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 <semaphore.h>
#include <vector>
#include <string>
#include <pthread.h>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 <iostream>
#include <unistd.h>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);
}