🌟 各位看官好，我是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 debug
template <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 debug
template <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等）及其在线程同步中的使用方法。文章重点演示了如何基于环形队列实现生产者-消费者模型，包括单生产单消费和多生产多消费场景的实现方案，并提供了完整的代码示例。最后，针对多线程环境提出了使用两把锁的解决方案，以平衡并发性能与线程安全性。
