我们今天接着来学习信号量：

什么是信号量

信号量（Semaphore）是一种用于操作系统中管理共享资源访问和同步的机制。它是一种特殊的数据结构，用来控制多个进程或线程对公共资源的访问，以防止多个进程同时对同一资源进行访问而导致的冲突问题。信号量维护了一个计数器，该计数器可以增加（通常称为V操作或Signal操作）或减少（称为P操作或Wait操作），并且这些操作都是原子的，即不可中断。

P操作（Wait操作）

• 当一个进程想要访问一个受保护的资源时，它会执行P操作。
• P操作会检查信号量的值，如果信号量大于0，则减1，并允许进程继续执行。
• 如果信号量等于0，表示资源已被占用，进程将被阻塞（等待）直到信号量的值变为非零。

V操作（Signal操作）

• 当一个进程完成对资源的访问后，它会执行V操作。
• V操作会将信号量的值加1，表示释放了一个资源。
• 如果有其他进程因为之前P操作而等待，此时可能会唤醒其中一个等待的进程。

信号量的类型

• 二值信号量：这种信号量只有0和1两种状态，相当于一个互斥锁，用于实现互斥访问。
• 计数信号量：可以用于控制有限数量的相同资源的访问，计数器的初始值代表资源的数量。

简单来说，信号量的本质就是一个容量为N的锁，跟一般的锁不一样，它可以放个多个线程访问临界资源，但是达到上限就不会让线程进入了，而让他们阻塞等待。

一些接口

在Linux环境下，信号量作为进程间通信的一种手段，主要用于同步和互斥控制。以下是Linux下信号量的一些常用接口，主要涉及System V信号量和POSIX信号量两种类型：

POSIX 信号量接口：

1. sem_init(sem_t *sem, int pshared, unsigned int value):
   

• 初始化一个POSIX信号量。sem 是信号量的地址，pshared 指定信号量是否可以在多进程中共享（如果为1则是共享的），value 是信号量的初始值。

2. sem_wait(sem_t *sem):[
   

• 执行P操作，如果信号量的值大于0，则减1并继续执行；否则，进程将被阻塞直到信号量的值大于0。

3. sem_post(sem_t *sem):
   

• 执行V操作，增加信号量的值，如果因此唤醒了等待的进程，则会选择一个进行唤醒。

4. sem_destroy(sem_t *sem):
   

• 销毁一个POSIX信号量。

5. sem_getvalue(sem_t *sem, int *sval):
   

• 获取POSIX信号量的当前值，sval 是存储信号量值的指针。

其他相关命令：

• ipcs: 查看系统中所有的IPC设施状态，包括消息队列、共享内存段和信号量。
• ipcrm: 删除指定的IPC设施，比如信号量集。

基于循环队列的生产者和消费者模型

我们这里模拟实现一个基于循环队列的生产者和消费者模型，首先我们实现一个循环队列：

先把架子搭好：

#include<iostream>
#include<semaphore>
#include<pthread.h>
#include<cstring>
#include<vector>
#include<semaphore.h>
#include<unistd.h>template<class T>
class CircleQueue
{
public:CircleQueue():_size(10),_product_start(0),_consum_start(0){}~CircleQueue(){}private:
};

现在，我们要分析一下，这里面的同步关系：

同步关系

我们这里清楚，生产者会消费一个空间生产一个产品，并往前走一步，并且生产者和消费者是指向一个空间：
消费者会消费一个产品，腾出一个空间资源，然后往前走一步：
这个时候，我们可以分析出以下几条信息：

1. 生产者一定先跑，因为一开始有空间资源，没有产品资源。
2. 消费者一定比生产者跑的慢，因为消费者的速度是受生产者产出产品的速度决定的。
3. 当空间资源被用完时，生产者停止生产，让消费者消费之后，腾出空间资源之后再继续生产。相反，如果没有产品资源，消费者阻塞，让生产者产出产品之后，再消费产品。

#include <iostream>
#include <semaphore>
#include <pthread.h>
#include <cstring>
#include <vector>
#include <semaphore.h>
#include <unistd.h>// 定义一个泛型循环队列类，利用信号量实现线程安全的生产者消费者模型
template <class T>
class CircleQueue {
public:// 默认构造函数，初始化一个大小为10的循环队列CircleQueue(): _size(10), // 队列默认容量_product_start(0), // 生产者开始位置_consum_start(0) // 消费者开始位置{// 初始化空间信号量，初始值为队列大小，表示可用空间数量sem_init(&_sem_space, 0, _size);// 初始化数据信号量，初始值为0，表示当前没有可消费的数据sem_init(&_sem_data, 0, 0);// 初始化队列容器_queue.resize(_size);}// 带参数构造函数，允许用户自定义队列大小CircleQueue(int size): _size(size), // 用户指定的队列容量_product_start(0),_consum_start(0){sem_init(&_sem_space, 0, size); // 根据用户指定的大小初始化空间信号量sem_init(&_sem_data, 0, 0);_queue.resize(size);}// 析构函数，释放信号量资源~CircleQueue() {sem_destroy(&_sem_space);sem_destroy(&_sem_data);}// 生产者方法，向队列中添加数据void Push(const T& data) {// 在尝试放入数据前，先等待确保有空闲空间sem_wait(&_sem_space);// 将数据放入队列的下一个生产位置_queue[_product_start] = data;// 更新生产者位置，并对索引取模以实现循环_product_start = (_product_start + 1) % _size;// 数据放入后，释放数据信号量，通知消费者有新数据可取sem_post(&_sem_data);}// 消费者方法，从队列中取出数据void Pop(T* out) {// 等待直到有数据可消费sem_wait(&_sem_data);// 从队列的下一个消费位置取出数据*out = _queue[_consum_start];// 更新消费者位置，并对索引取模实现循环_consum_start = (_consum_start + 1) % _size;// 数据取出后，释放空间信号量，表明队列中有更多空间可填充sem_post(&_sem_space);}private:// 循环队列的底层数据结构std::vector<T> _queue;int _size; // 队列的最大容量// 生产者和消费者的当前位置索引int _product_start;int _consum_start;// 信号量用于同步控制sem_t _sem_space; // 控制队列中的空闲空间sem_t _sem_data; // 控制队列中的有效数据量
};

这段代码实现了一个基于信号量的线程安全循环队列模板类。它支持生产者线程向队列中添加元素（通过Push方法），同时允许消费者线程从队列中取出元素（通过Pop方法）。通过使用两个信号量——_sem_space 和 _sem_data——分别管理队列的可用空间和有效数据量，确保了多线程环境下的正确同步与互斥。

基于这个，我们实现一下整体的代码：

#include"CircleQueue.hpp"
#include<time.h>void* product(void* args)
{CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);while(true){//生产数据int randomdata = rand() % 10 + 1;cq->Push(randomdata);std::cout << "Producter has product a number: " << randomdata <<std::endl; }return nullptr;
}void* consum(void* args)
{CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);while(true){//拿出数据int outnumber = 0;cq->Pop(&outnumber);std::cout << "Consum gets a number: " << outnumber <<std::endl; sleep(1);}return nullptr;
}int main()
{srand(time(0));//创建线程pthread_t tid_product,tid_consum;CircleQueue<int>*cq = new CircleQueue<int>();//生产者pthread_create(&tid_product,nullptr,product,cq);//消费者pthread_create(&tid_consum,nullptr,consum,cq);pthread_join(tid_product,nullptr);pthread_join(tid_consum,nullptr);
}

大家可以调整一下生产者或者消费者的速度，看看情况怎么样。

多生产多消费

这里注意一下，这里和互斥锁的情况有点不一样：

我们用一个通俗的例子来解释：

假设有一天，你和你的好朋友（一共8个人），想去电影院看电影：

你们到售票机哪里去买票，此时电影院的座位很充足，所以你们都买到票了。
但是一看座位号，发现大家全都是1号座位

这就很尴尬了，这个场景可以类比到我们上面的代码中，8个线程通过了信号量，但是都在往一个位置位置放东西，这样不行，所以我们得出位置是每个人独有的，一人一份，如果自己拥有，别人就不能拥有，所以为了保证每一个位置为一人独有所以我们要给每个位置上锁（电影院的座位）

如果有点绕，咋们来复盘一下：

1. 电影院有很多位置，所以，我们多人可以都得到属于自己的位置（类比我们的循环队列）
2. 为了保证我们的位置是独一无二属于自己，我们要给自己的位置上锁，保证只有自己可以坐这个座位。（类比循环队列中的下标）

解决完上面的问题，我们现在要做的，就是还要两把锁，一个保证生产的时候，放入时候的位子只属于一个生产者进程，另一把锁保证从一个位置里面拿产品的时候只属于一个消费者进程：

#include <iostream>
#include <semaphore>
#include <pthread.h>
#include <cstring>
#include <vector>
#include <semaphore.h>
#include <unistd.h>// 定义一个泛型循环队列类，结合信号量与互斥锁实现线程安全的生产者消费者模型
template <class T>
class CircleQueue {
public:// 默认构造函数，初始化一个大小为10的循环队列，并初始化信号量与互斥锁CircleQueue(): _size(10), // 队列默认容量_product_start(0), // 生产者开始位置_consum_start(0) // 消费者开始位置{sem_init(&_sem_space, 0, _size); // 初始化空间信号量，初始值为队列大小sem_init(&_sem_data, 0, 0); // 初始化数据信号量，初始值为0pthread_mutex_init(&_p_mutex, nullptr); // 初始化生产者互斥锁pthread_mutex_init(&_c_mutex, nullptr); // 初始化消费者互斥锁_queue.resize(_size); // 初始化队列向量}// 带参数构造函数，允许自定义队列大小CircleQueue(int size): _size(size),_product_start(0),_consum_start(0){sem_init(&_sem_space, 0, size);sem_init(&_sem_data, 0, 0);pthread_mutex_init(&_p_mutex, nullptr);pthread_mutex_init(&_c_mutex, nullptr);_queue.resize(size);}// 析构函数，释放信号量与互斥锁资源~CircleQueue() {sem_destroy(&_sem_space);sem_destroy(&_sem_data);pthread_mutex_destroy(&_p_mutex);pthread_mutex_destroy(&_c_mutex);}// 生产者方法，向队列中添加数据void Push(const T& data) {// 确保有足够的空间再进行生产sem_wait(&_sem_space);// 使用互斥锁保护生产过程，防止与其它生产者并发冲突pthread_mutex_lock(&_p_mutex);_queue[_product_start] = data; // 添加数据_product_start = (_product_start + 1) % _size; // 更新生产者位置pthread_mutex_unlock(&_p_mutex); // 释放锁sem_post(&_sem_data); // 数据添加完毕，释放数据信号量}// 消费者方法，从队列中取出数据void Pop(T* out) {// 确保有数据可消费sem_wait(&_sem_data);// 使用互斥锁保护消费过程pthread_mutex_lock(&_c_mutex);*out = _queue[_consum_start]; // 取出数据_consum_start = (_consum_start + 1) % _size; // 更新消费者位置pthread_mutex_unlock(&_c_mutex); // 释放锁sem_post(&_sem_space); // 释放空间信号量}private:// 循环队列的底层数据结构std::vector<T> _queue;int _size; // 队列的最大容量// 生产者和消费者的当前位置索引int _product_start;int _consum_start;// 同步控制工具sem_t _sem_space; // 控制队列中的空闲空间sem_t _sem_data; // 控制队列中的有效数据量// 互斥锁用于保护队列访问的原子性pthread_mutex_t _p_mutex; // 生产者使用的互斥锁pthread_mutex_t _c_mutex; // 消费者使用的互斥锁
};

这里打印的时候，由于屏幕也是公共资源，我这里加锁，是保证打印的时候，只有生产者或者消费者打印信息：

#include"CircleQueue.hpp"
#include<time.h>pthread_mutex_t global_mutex = PTHREAD_MUTEX_INITIALIZER;void* product(void* args)
{CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);while(true){//生产数据int randomdata = rand() % 10 + 1;cq->Push(randomdata);pthread_mutex_lock(&global_mutex);std::cout << "Producter has product a number: " << randomdata <<std::endl; pthread_mutex_unlock(&global_mutex);}return nullptr;
}void* consum(void* args)
{CircleQueue<int>* cq = static_cast<CircleQueue<int>*>(args);while(true){//拿出数据int outnumber = 0;cq->Pop(&outnumber);pthread_mutex_lock(&global_mutex);std::cout << "Consum gets a number: " << outnumber <<std::endl; pthread_mutex_unlock(&global_mutex);sleep(1);}return nullptr;
}int main()
{srand(time(0));//创建线程pthread_t tid_product[8],tid_consum[8];CircleQueue<int>*cq = new CircleQueue<int>();//生产者for(int i = 0; i < 8; i++){pthread_create(&tid_product[i],nullptr,product,cq);}//消费者for(int i = 0; i < 8; i++){pthread_create(&tid_consum[i],nullptr,consum,cq);}for(int i = 0; i < 8; i++){pthread_join(tid_product[i],nullptr);}for(int i = 0; i < 8; i++){pthread_join(tid_consum[i],nullptr);}}