[linux仓库]多线程同步：基于POSIX信号量实现生产者-消费者模型[线程·柒]
🌟 各位看官好，我是egoist2023！
🌍 Linux == Linux is not Unix ！
🚀 今天来学习Linux的System V信号量,基于该信号量实现生产者消费者模型的代码。
👍 如果觉得这篇文章有帮助，欢迎您一键三连，分享更多人哦！
目录
回顾System V信号量
认识信号量接口
环形队列
单单CP场景
代码实现
生产数据
消费数据
多多CP场景
总结
回顾System V信号量
还记得这张图不?这是当年在讲进程通信时候,通过讲述电影院的故事,画出的图.上一节我们又有了阻塞队列的知识储备.
阻塞队列当成整体使用,如果此时拆分成一个个小资源呢?让不同的线程访问同一块资源的不同部分,那么不就相当于允许多个线程并发访问同一块资源了吗
整体使用就是要有互斥能力;
局部使用,访问错了,分多资源应该要规避
- 放过多线程进入,本质就是访问信号量,而信号量本质是一把计数器!(信号量就是一个计数器,可以理解为锁+整数) --> 那么该如何表示信号量还剩多少资源,资源被申请多少了呢? PV操作
要申请信号量 --> 前提是看到同一个信号量 --> 信号量本身就要是共享资源 --> 如何保证自己的安全? --> PV操作是原子性的
- 让不同的线程,访问同一块资源的不同部分,这个资源在哪里呢?需要让程序员做!
POSIX信号量
POSIX信号量和SystemV信号量作⽤相同，都是⽤于同步操作，达到⽆冲突的访问共享资源⽬的。但POSIX可以⽤于线程间同步。
认识信号量接口
int sem_init(sem_t *sem, int pshared, unsigned int value);
功能:初始化信号量
参数：
pshared:0表⽰线程间共享，⾮零表⽰进程间共享
value：信号量初始值
int sem_destroy(sem_t *sem);功能:销毁信号量
int sem_wait(sem_t *sem); P操作功能:等待信号量，会将信号量的值减1
int sem_post(sem_t *sem); V操作功能：发布信号量，表⽰资源使⽤完毕，可以归还资源了。将信号量值加1。
上⼀节⽣产者-消费者的例⼦是基于queue的,其空间可以动态分配,现在基于固定⼤⼩的环形队列重写这个程序（POSIX信号量）:
环形队列
单单CP场景
我们现在有信号量这个计数器，就很简单的进⾏多线程间的同步过程。
- 为空的时候，必须让生产者先运行 --> 生产和消费会访问同一个位置 --> 互斥放入数据 --> 这不就是生产和消费者的互斥与同步关系!
- 为满的时候,必须让消费者先运行 --> 生产和消费又指向同一个位置了! --> 互斥的获取数据 --> 这不就是生产和消费者的互斥与同步关系!
- 不为空 && 不为满:此时首 != 尾 ,访问的一定不是同一个位置! --> 此时,不就可以并发执行了?!
代码实现
信号量Sem.hpp封装
class Sem
{
public:Sem(int initnum) : _initnum(initnum){sem_init(&_sem, 0, _initnum);}void P(){int n = sem_wait(&_sem);(void)n;}void V(){int n = sem_post(&_sem);(void)n;}~Sem(){sem_destroy(&_sem);}private:sem_t _sem;int _initnum;
};RingQueue.hpp
static int gcap = 5; // for debugtemplate <typename T>
class RingQueue
{
public:RingQueue(int cap = gcap): _cap(cap), _ring_queue(cap), _space_sem(cap), _data_sem(0), _p_step(0), _c_step(0){}private:std::vector<T> _ring_queue; // 临界资源int _cap;Sem _space_sem;Sem _data_sem;// 生产和消费的位置int _p_step;int _c_step;
};生产数据
因为是单生产单消费:
- 不担心同时有两个生产者来访问;
- 生产者访问期间,消费者不可能来打扰我,一定不为满,最多也就是不为空&不为满,二者可以并发执行,消费者并不影响生产者
void Enqueue(const T &in){_space_sem.P();{// 生产数据了！有空间，在哪里啊？？_ring_queue[_p_step++] = in;// 维持环形特点_p_step %= _cap;}_data_sem.V();}消费数据
只要消费者走到了*out = _ring_queue[_c_step++,证明队列一定不为空.
void Pop(T *out){_data_sem.P();{*out = _ring_queue[_c_step++];_c_step %= _cap;}_space_sem.V();}
多多CP场景
如果是多生产多消费呢?就还需要维护生产者之间、消费者之间的互斥关系,那要加几把锁呢?一把锁就放弃了让生产者和消费者并发运行的情况,降低效率.引入两把锁,生产者之间竞争这把锁,消费者之间竞争者这把锁,本质还是归宿到单生产单消费了
static int gcap = 5; // for debugtemplate <typename T>
class RingQueue
{
public:RingQueue(int cap = gcap): _cap(cap), _ring_queue(cap), _space_sem(cap), _data_sem(0), _p_step(0), _c_step(0){}void Pop(T *out){_data_sem.P();{LockGuard lockguard(&_c_lock);*out = _ring_queue[_c_step++];_c_step %= _cap;}_space_sem.V();}void Enqueue(const T &in){_space_sem.P();{LockGuard lockguard(&_p_lock);// 生产数据了！有空间，在哪里啊？？_ring_queue[_p_step++] = in;// 维持环形特点_p_step %= _cap;}_data_sem.V();}~RingQueue(){}private:std::vector<T> _ring_queue; // 临界资源int _cap;Sem _space_sem;Sem _data_sem;// 生产和消费的位置int _p_step;int _c_step;// 两把锁Mutex _p_lock;Mutex _c_lock;
};main.cc
// 基于信号量形成的生产者消费者模型
void *consumer(void *args)
{RingQueue<int> *rq = static_cast<RingQueue<int> *>(args);while (true){int data = 0;rq->Pop(&data);std::cout << "消费了一个数据: " << data << std::endl;}
}void *productor(void *args)
{RingQueue<int> *rq = static_cast<RingQueue<int> *>(args);int data = 1;while (true){sleep(1);rq->Enqueue(data);std::cout << "生产了一个数据: " << data << std::endl;data++;}
}int main()
{RingQueue<int> *rq = new RingQueue<int>();pthread_t c[2], p[3];pthread_create(c, nullptr, consumer, (void *)rq);pthread_create(c + 1, nullptr, consumer, (void *)rq);pthread_create(p, nullptr, productor, (void *)rq);pthread_create(p + 1, nullptr, productor, (void *)rq);pthread_create(p + 3, nullptr, productor, (void *)rq);pthread_join(c[0], nullptr);pthread_join(c[1], nullptr);pthread_join(p[0], nullptr);pthread_join(p[1], nullptr);pthread_join(p[2], nullptr);delete rq;return 0;
}总结
本文介绍了Linux系统中信号量的概念及其在多线程编程中的应用。首先回顾了SystemV信号量的工作原理，通过计数器机制实现资源共享。然后详细讲解了POSIX信号量接口（sem_init、sem_wait等）及其在线程同步中的使用方法。文章重点演示了如何基于环形队列实现生产者-消费者模型，包括单生产单消费和多生产多消费场景的实现方案，并提供了完整的代码示例。最后，针对多线程环境提出了使用两把锁的解决方案，以平衡并发性能与线程安全性。
