长沙电商网站制作小说网站制作
POSIX信号量
信号量本质是一个计数器，是对特定资源的预定机制!
多线程使用资源，有两种情况：
1.将目标资源整体使用【mutex+2元信号量】
2.将目标资源按照不同的“块”，分批使用【信号量】
所有的线程，都得看到同一份资源sem，信号量本身也是临界资源。
信号量的P：--，原子的；V：++，原子的
2.CP&基于环形队列的生产者消费者模型
回顾数据结构环形队列：
逻辑上，环形队列是个圆，大小固定。
对于空和满的判定：
方案一：int count; 记录当前数据的数量
方案二：空一格，head和tail相等为空，tail下一个是head为满。
实现方式：
可以用一个长度固定的数组实现，下标每次++后就 %= 长度，就可以实现回绕。
具体实现：
约定1：空，生产者先运行
约定2：满，消费者先运行
约定3：生产者不能套消费者一圈以上
约定4：消费者不能超过生产者
思考：
1.只要消费者和生产者不在同一位置，就互不干扰，可以并发执行。
2.什么时候消费者和生产者在同一位置？空或满的时候，只要不为空或满就可以同时运行。
3.为空，只能（互斥）生产者先执行（同步，顺序固定）
为满，只能（互斥）消费者先执行（同步，顺序固定）
因此，当前思路就保证了生产者和消费者之间的：互斥（只能有一个） 和 同步（固定先后）
对于生产者来说，空位置是资源；对于消费者来说，数据是资源
伪代码呈现思路：
生产者 消费者
初始（sem_blank = N, p_step = 0） (sem_data = 0, c_step = 0 )
P(sem_blank); // 空位置-- P(sem_data);
在p_step的位置生产 在c_step的位置消费
p_step++; c_step++;
p_step %= N; // 保持环形队列 c_step %= N;
V(sem_data); // 数据++ V(sem_blank);
注：信号量P操作是原子的，申请成功，继续运行，申请失败，申请的线程会被阻塞。
分析整个流程，各个情况，以单生产者，单消费者来看：
情况1：sem_blank为N，sem_data为0，为空的情况
生产者线程P操作成功，消费者P操作会阻塞，直到生产者V操作把sem_data++。
情况2：sem_blank为0，sem_data为N，为满的情况
生产者P操作阻塞，消费者P操作成功，直到消费者V操作把sem_blank++。
情况3：sem_blank为x, sem_data为N-x，x>0，其他情况
两者P操作都可以成功，互不干扰，可以并发执行
总结：
环形队列用信号量来实现生产者消费者模型的原因：环形队列的长度固定，资源明确划分，资源数量确定。生产者和消费者在进行同一块资源访问时，必有一个信号量为0，要阻塞，等待另一个V操作++，这样就保证了同步和互斥；访问不同块资源时，没有任何限制，可以并发执行。
3.熟悉信号量的接口，编写代码
#include <semaphore.h>
sem_t sem;
初始化：
sem_init(&sem, 0, value); //第二个参数0表示线程间共享，非0表示进程间共享；第三个参数value表示信号量的初始值
销毁：
sem_destroy(&sem);
等待信号量（P操作，--）：
sem_wait(&sem);
发布信号量（V操作，++）：
sem_post(&sem);
信号量的封装：
#pragma once #include <semaphore.h>class Sem { public:Sem(unsigned int num){sem_init(&_sem, 0, num);}~Sem(){sem_destroy(&_sem);}void P(){sem_wait(&_sem);}void V(){sem_post(&_sem);}private:sem_t _sem; };RingQueue.hpp实现：
#pragma once#include "Sem.hpp" #include <vector> #include "Mutex.hpp"using namespace MutexModule; static const unsigned int defaultnum = 5;template<typename T> class RingQueue { public:RingQueue(unsigned int cap = defaultnum): _v(cap, 0), _cap(cap), _pstep(0), _cstep(0), _sem_blank(cap), _sem_data(0){}~RingQueue(){}void EnQueue(const T &data){// 生产者_sem_blank.P();{// 先竞争信号量，再竞争锁，效率更高MutexGuard mutexguard(_pmutex);// 1.执行_pstep位置的任务_v[_pstep] = data;// 2.迭代_pstep++;// 3.维持环形队列结构_pstep %= _cap;}_sem_data.V();}void Pop(T *data){// 消费者_sem_data.P();{MutexGuard mutexguard(_cmutex);*data = _v[_cstep];_cstep++;_cstep %= _cap;}_sem_blank.V();}private:std::vector<T> _v; // 数组模拟环形队列int _cap; // 环形队列容量int _pstep; // 生产者下标int _cstep; // 消费者下标Sem _sem_blank; // 空位置信号量，生产者资源Sem _sem_data; // 数据信号量，消费者资源Mutex _pmutex; // 生产者间的互斥锁Mutex _cmutex; // 消费者间的互斥锁 };注意的点：信号量只能保证生产者和消费者之间的互斥和同步关系。
为了实现多生产者和多消费者，需要实现生产者间的互斥关系，消费者间的互斥关系。
锁的申请要在申请信号量之后，原因：
1）信号量的PV操作是原子的，不用锁保护
2）先竞争信号量，再竞争锁，效率更高 -> 先申请信号量，线程是并行执行的，可以让线程先持有资源，在申请锁成功可以直接执行临界区代码；若是先申请锁，那么每次只能有一个线程去竞争信号量，其他线程在锁释放前什么也做不了，效率低下 -> 这也是锁要尽可能细的加在临界区之间，尽量不要包含非临界区代码的原因
