我们将可能会被多个执行流同时访问的资源叫做临界资源，临界资源需要进行保护否则会出现数据不一致等问题。
当我们仅用一个互斥锁对临界资源进行保护时，相当于我们将这块临界资源看作一个整体，同一时刻只允许一个执行流对这块临界资源进行访问。
但实际我们可以将这块临界资源再分割为多个区域，当多个执行流需要访问临界资源时，如果这些执行流访问的是临界资源的不同区域，那么我们可以让这些执行流同时访问临界资源的不同区域，此时不会出现数据不一致等问题。
信号量（信号灯）本质是一个计数器，是描述临界资源中资源数目的计数器，信号量能够更细粒度的对临界资源进行管理。
每个执行流在进入临界区之前都应该先申请信号量，申请成功就有了操作特点的临界资源的权限，当操作完毕后就应该释放信号量。
信号量的PV操作：
PV操作必须是原子操作
多个执行流为了访问临界资源会竞争式的申请信号量，因此信号量是会被多个执行流同时访问的，也就是说信号量本质也是临界资源。
但信号量本质就是用于保护临界资源的，我们不可能再用信号量去保护信号量，所以信号量的PV操作必须是原子操作。
注意： 内存当中变量的++、–操作并不是原子操作，因此信号量不可能只是简单的对一个全局变量进行++、–操作。
申请信号量失败被挂起等待
当执行流在申请信号量时，可能此时信号量的值为0，也就是说信号量描述的临界资源已经全部被申请了，此时该执行流就应该在该信号量的等待队列当中进行等待，直到有信号量被释放时再被唤醒。
注意： 信号量的本质是计数器，但不意味着只有计数器，信号量还包括一个等待队列。
初始化信号量
初始化信号量的函数叫做sem_init，该函数的函数原型如下：
int sem_init(sem_t *sem, int pshared, unsigned int value);
参数说明：
返回值说明：
注意： POSIX信号量和System V信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的，但POSIX信号量可以用于线程间同步。
销毁信号量
销毁信号量的函数叫做sem_destroy，该函数的函数原型如下：
int sem_destroy(sem_t *sem);
参数说明：
返回值说明：
等待信号量（申请信号量）
等待信号量的函数叫做sem_wait，该函数的函数原型如下：
int sem_wait(sem_t *sem);
参数说明：
返回值说明：
发布信号量（释放信号量）
发布信号量的函数叫做sem_post，该函数的函数原型如下：
int sem_post(sem_t *sem);
参数说明：
返回值说明：
信号量本质是一个计数器，如果将信号量的初始值设置为1，那么此时该信号量叫做二元信号量。
信号量的初始值为1，说明信号量所描述的临界资源只有一份，此时信号量的作用基本等价于互斥锁。
生产者关注的是空间资源，消费者关注的是数据资源
对于生产者和消费者来说，它们关注的资源是不同的：
blank_sem和data_sem的初始值设置
现在我们用信号量来描述环形队列当中的空间资源（blank_sem）和数据资源（data_sem），在我们初始信号量时给它们设置的初始值是不同的：
生产者申请空间资源，释放数据资源
对于生产者来说，生产者每次生产数据前都需要先申请blank_sem：
当生产者生产完数据后，应该释放data_sem：
消费者申请数据资源，释放空间资源
对于消费者来说，消费者每次消费数据前都需要先申请data_sem：
当消费者消费完数据后，应该释放blank_sem：
在基于环形队列的生产者和消费者模型当中，生产者和消费者必须遵守如下两个规则。
第一个规则：生产者和消费者不能对同一个位置进行访问。
生产者和消费者在访问环形队列时：
第二个规则：无论是生产者还是消费者，都不应该将对方套一个圈以上。
#pragma once
#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
#include <vector>
#define NUM 8
template<class T>
class RingQueue
{
private:
//P操作
void P(sem_t& s)
{
sem_wait(&s);
}
//V操作
void V(sem_t& s)
{
sem_post(&s);
}
public:
RingQueue(int cap = NUM)
: _cap(cap), _p_pos(0), _c_pos(0)
{
_q.resize(_cap);
sem_init(&_blank_sem, 0, _cap); //blank_sem初始值设置为环形队列的容量
sem_init(&_data_sem, 0, 0); //data_sem初始值设置为0
}
~RingQueue()
{
sem_destroy(&_blank_sem);
sem_destroy(&_data_sem);
}
//向环形队列插入数据（生产者调用）
void Push(const T& data)
{
P(_blank_sem); //生产者关注空间资源
_q[_p_pos] = data;
V(_data_sem); //生产
//更新下一次生产的位置
_p_pos++;
_p_pos %= _cap;
}
//从环形队列获取数据（消费者调用）
void Pop(T& data)
{
P(_data_sem); //消费者关注数据资源
data = _q[_c_pos];
V(_blank_sem);
//更新下一次消费的位置
_c_pos++;
_c_pos %= _cap;
}
private:
std::vector<T> _q; //环形队列
int _cap; //环形队列的容量上限
int _p_pos; //生产位置
int _c_pos; //消费位置
sem_t _blank_sem; //描述空间资源
sem_t _data_sem; //描述数据资源
};
相关说明：
为了方便理解，我们这里实现单生产者、单消费者的生产者消费者模型。于是在主函数我们就只需要创建一个生产者线程和一个消费者线程，生产者线程不断生产数据放入环形队列，消费者线程不断从环形队列里取出数据进行消费。
#include "RingQueue.hpp"
void* Producer(void* arg)
{
RingQueue<int>* rq = (RingQueue<int>*)arg;
while (true){
sleep(1);
int data = rand() % 100 + 1;
rq->Push(data);
std::cout << "Producer: " << data << std::endl;
}
}
void* Consumer(void* arg)
{
RingQueue<int>* rq = (RingQueue<int>*)arg;
while (true){
sleep(1);
int data = 0;
rq->Pop(data);
std::cout << "Consumer: " << data << std::endl;
}
}
int main()
{
srand((unsigned int)time(nullptr));
pthread_t producer, consumer;
RingQueue<int>* rq = new RingQueue<int>;
pthread_create(&producer, nullptr, Producer, rq);
pthread_create(&consumer, nullptr, Consumer, rq);
pthread_join(producer, nullptr);
pthread_join(consumer, nullptr);
delete rq;
return 0;
}
相关说明：
在blank_sem和data_sem两个信号量的保护后，该环形队列中不可能会出现数据不一致的问题。
因为只有当生产者和消费者指向同一个位置并访问时，才会导致数据不一致的问题，而此时生产者和消费者在对环形队列进行写入或读取数据时，只有两种情况会指向同一个位置：
但是在这两种情况下，生产者和消费者不会同时对环形队列进行访问：
也就是说，当环形队列为空和满时，我们已经通过信号量保证了生产者和消费者的串行化过程。而除了这两种情况之外，生产者和消费者指向的都不是同一个位置，因此该环形队列当中不可能会出现数据不一致的问题。并且大部分情况下生产者和消费者指向并不是同一个位置，因此大部分情况下该环形队列可以让生产者和消费者并发的执行