目录
POSIX信号量
信号量原理
信号量概念
信号量函数
基于环形队列的生产者消费者模型
生产者和消费者申请和释放资源
单生产者单消费者
多生产者多消费者
多生产者多消费者的意义
信号量的意义
POSIX信号量
信号量原理
- 如果仅用一个互斥锁对临界资源进行保护，相当于把这块临界资源看作一个整体，同一时间只允许一个执行流对这块临界资源进行访问。
- 如果将这块临界资源再分成多个区域，当多个执行流需要访问临界资源时，如果这些执行流访问的是临界资源的不同区域，那就可以继续并发访问，访问同一个资源的时候再进行同步和互斥。
信号量概念
信号量本质上就是一个计数器，记录的是临界资源中资源数目的计数器，它可以更细粒度的对临界资源进行管理。
访问临界资源的时候，先申请信号量，信号量的值--，这叫做预定资源，我们叫做P操作；使用完后，信号量的值++，这叫做释放资源，我们叫做V操作。
当我们申请了一个信号量，可以保证当前执行流一定具有一个资源，要说是哪一个那就需要我们自己编写代码决定了。
信号量函数
作用：初始化信号量
参数：
- sem：需要初始化的信号量
- pshared：传入0表示线程间共享，传入非0表示进程间共享
- value：信号量的初始值（类似一个计数器）
返回值：成功返回0，失败返回-1，错误码被设置。
作用：销毁信号量
参数：要销毁的信号量
返回值：成功返回0，失败返回-1，错误码被设置。
作用：等待信号量
参数：要等待的信号量
返回值：
- 等待信号量成功返回0，信号量的值减一。
- 等待信号量失败返回-1，信号量的值保持不变。
作用：释放信号量
参数：需要释放的信号量
返回值：
- 发布信号量成功返回0，信号量的值加一。
- 发布信号量失败返回-1，信号量的值保持不变。
基于环形队列的生产者消费者模型
生产者最看重的就是队列中的空间，而消费者最看重的就是队列中的数据。只要有空间就可以生产数据，只要有数据就可以消费。
用信号量来表示上述的数据：
- spaceSem：表示有多少空间，开始设为N（队列长度）。
- dataSem：表示有多少数据，开始设为0。
生产者和消费者申请和释放资源
当生产数据的时候：
P(spaceSem)
spaceSem--;
// 生产数据
V(dataSem)
dataSem++;
当消费数据的时候
P(dataSem)
dataSem--;
// 消费数据
V(spaceSem)
spaceSem++;
当两个执行流同时访问的时候：
- 如果消费者先执行，要P（申请）dataSem（数据），但是一开始的dataSem的值是0，所以就被阻塞了。
- 如果生产者先运行，要P（申请）spaceSem（空间），一开始的spaceSem的值是N，就可以申请成功，生产数据，之后V（释放）dataSem（数据）。
- 如果生产者把数据放满了，要P（申请）spaceSem（空间）就会失败，生产者就被阻塞。
- 如果两个执行流都能获取想要的资源，那就可以实现并发访问。
单生产者单消费者
// Sem.hpp
#include <iostream>
#include <pthread.h>
#include <semaphore.h>
// 封装一下信号量
class Sem
{
public:
Sem(int value)
{
sem_init(&_sem, 0, value);
}
void P()
{
sem_wait(&_sem);
}
void V()
{
sem_post(&_sem);
}
~Sem()
{
sem_destroy(&_sem);
}
private:
sem_t _sem;
};
// ringQueue.hpp
#include <iostream>
#include <vector>
#include <pthread.h>
#include <unistd.h>
#include "Sem.hpp"
using namespace std;
const int g_default_num = 5;
template <class T>
class RingQueue
{
public:
RingQueue(int default_num = g_default_num)
:_ring_queue(default_num)
,_num(default_num)
,_c_step(0)
,_p_step(0)
,_space_sem(default_num)
,_data_sem(0)
{}
~RingQueue()
{}
// 生产者
void push(const T& in)
{
_space_sem.P();
_ring_queue[_p_step++] = in;
_p_step %= _num;
_data_sem.V();
}
// 消费者
void pop(T* out)
{
_data_sem.P();
*out = _ring_queue[_c_step++];
_c_step %= _num;
_space_sem.V();
}
void debug()
{
cout << "size: " << _num << "queue: " << _ring_queue.size() << endl;
}
private:
vector<T> _ring_queue;
size_t _num;
int _c_step; // 消费者下标
int _p_step; // 生产者下标
Sem _space_sem; // 空间信号量
Sem _data_sem; // 数据信号量
};
// testMain.cc
#include "ringQueue.hpp"
#include <ctime>
void* consumer(void* args)
{
RingQueue<int>* rq = (RingQueue<int>*)args;
while (true)
{
int x;
// 1.从环形队列中获取任务
rq->pop(&x);
// 2.进行处理
cout << "消费：" << x << endl;
// sleep(1);
}
}
void* productor(void* args)
{
RingQueue<int>* rq = (RingQueue<int>*)args;
while (true)
{
// 1.构建数据或任务对象，数据可能从任何地方来，那一定会有时间消耗
int x = rand() % 10 + 1;
// 2.推送到环形队列
rq->push(x);
cout << "生产：" << x << endl;
// sleep(1);
}
}
int main()
{
srand((unsigned)time(nullptr) ^ getpid());
RingQueue<int>* rq = new RingQueue<int>();
pthread_t c, p;
pthread_create(&c, nullptr, consumer, (void*)rq);
pthread_create(&p, nullptr, productor, (void*)rq);
pthread_join(c, nullptr);
pthread_join(p, nullptr);
return 0;
}
与基于阻塞队列的生产者消费者模型不同的是，阻塞队列是一块临界资源，就会有互斥和同步的问题，生产者和消费者访问临界资源的时候就要加互斥锁来保护临界资源，用信号量实现没有使用互斥锁，我们把资源的数目规定好，通过管理这些资源的数量，就可以对每一块资源更细粒度的管理。
关于环形队列的实现就不过多赘述了，就是控制下标加上模运算。生产者消费者只要访问的不是环形队列中的相同区域，他们两个基本就没有关系，所以可以实现并发访问。我们维护的只有生产者和消费者之间的互斥和同步关系。
多生产者多消费者
如果是多生产和多消费该怎么做呢？我们要知道的是相比于单生产单消费要多维护什么关系，其实就是生产和生产间、消费和消费间的这两种互斥关系。
如果只加一把锁，本来生产和消费可以有很大概率并发执行，现在又多了锁的竞争，就可能变成串行执行，一把不行，那就加两把。
生产者之间的临界资源就是空间，消费者之间的临界资源就是数据。
既然有了锁就可以保护临界资源了，那么我是先申请信号量还是先申请锁呢？假如先申请锁，锁申请成功了，再申请信号量，此时就可能有很多信号量还没有分配出去，前面我们也说过，这个信号量是一种预定机制，即便申请了信号量也没有使用资源，那为何不先申请信号量呢，所以一般都是先申请信号量再加锁。
const int g_default_num = 5;
template <class T>
class RingQueue
{
public:
RingQueue(int default_num = g_default_num)
:_ring_queue(default_num)
,_num(default_num)
,_c_step(0)
,_p_step(0)
,_space_sem(default_num)
,_data_sem(0)
{
pthread_mutex_init(&_clock, nullptr);
pthread_mutex_init(&_plock, nullptr);
}
~RingQueue()
{
pthread_mutex_destroy(&_clock);
pthread_mutex_destroy(&_plock);
}
// 生产者
void push(const T& in)
{
_space_sem.P();
pthread_mutex_lock(&_plock);
_ring_queue[_p_step++] = in;
_p_step %= _num;
pthread_mutex_unlock(&_plock);
_data_sem.V();
}
// 消费者
void pop(T* out)
{
_data_sem.P();
pthread_mutex_lock(&_clock);
*out = _ring_queue[_c_step++];
_c_step %= _num;
pthread_mutex_unlock(&_clock);
_space_sem.V();
}
void debug()
{
cout << "size: " << _num << "queue: " << _ring_queue.size() << endl;
}
private:
vector<T> _ring_queue;
size_t _num;
int _c_step; // 消费者下标
int _p_step; // 生产者下标
Sem _space_sem; // 空间信号量
Sem _data_sem; // 数据信号量
pthread_mutex_t _clock; // 消费者之间的锁
pthread_mutex_t _plock; // 生产者之间的锁
};
多生产者多消费者的意义
其实生产者往容器缓冲区中放数据和消费者从容器缓冲区中拿数据，就是一个生产者在放，一个消费者在拿，那它的意义在哪呢？
我们要思考的是，我们从哪里拿到的任务也就是生产任务前，我们拿到任务后该怎么做，如果只有一个执行流，它既要做这个也要做那个，中间还得加锁，那任务就是一个一个做的，如果使用多线程，那么多个线程就可以并发的处理这些动作。
信号量的意义
信号量的意义是什么呢？
看到这里是一定会带有问题的，阻塞队列时，我们要先申请锁，再检测，不成功就阻塞，唤醒后在检测，成功后再执行，但是使用信号量都没有检测，甚至可能都没有加锁。
其实阻塞队列中我们并不清楚临界资源的情况，但信号量是一个计数器，它可以预定某种资源，在PV操作中我们也可以知道临界资源的情况。
