POSIX 信号量

信号量的原理

我们将可能会被多个执行流同时访问的资源叫做临界资源，当我们仅用一个互斥锁对临界资源进行保护时，相当于我们把这块临界资源看作一个整体，同一时刻只允许一个执行流对这块临界资源进行访问。但是实际上我们可以将这块临界资源分割成多个区域，当多个执行流访问临界资源时，如果这些执行流访问的是临界资源的不同区域，那么就不会出现数据不一致问题

信号量的概念

信号量本质是一个计数器，是描述临界资源中资源数目的计数器，信号量能够以更细的粒度对临界资源进行管理。每个执行流在进入临界区之前都应该先申请信号量，申请成功就有了操作特定区域临界资源的权限，当操作完毕后就释放信号量

信号量的操作有两种： P操作（申请）和V操作（释放），PV操作都是原子操作

多个执行流为了争夺访问临界资源的权限会竞争式申请信号量，因此信号量会被多个执行流同时访问的，也就是信号量本身就是临界资源。信号量的PV操作必须是原子操作，所以信号量PV操作不能描述成简单的对全局变量++,--

信号量本质是计数器，但不意味着只有计数器，信号量还包括一个等待队列

信号量的接口

初始化信号量

int sem_init(sem_t *sem, int pshared, unsigned int value);

sem ：需要初始化的信号量
pshared : 传入0值表示线程间共享，传入非零值表示进程间共享
value : 信号量的初始值（计数器的初始值）
成功返回0，失败返回-1

POSIX信号量和System V信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源的目的，但POSIX信号量可以用于线程同步

销毁信号量

int sem_destroy(sem_t *sem);

sem ：需要销毁的信号量
销毁信号量成功返回0，失败返回-1

等待信号量（申请信号量）

int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);

sem：需要等待的信号量
等待信号量成功返回0，信号量的值减一。等待信号量失败返回-1，信号量的值保持不变

发布信号量（释放信号量）

int sem_post(sem_t *sem);

sem: 需要发布的信号量
发布信号量成功返回0，信号量+1，发布失败返回-1，信号量值不变

二元信号量实战

信号量本质就是一个计数器，如果将信号量的初始值设置为1，那么该信号量叫做二元信号量

// 封装信号量
#pragma once 
#include <iostream>
#include <unistd.h>
#include <semaphore.h>
using namespace std;class clx_sem{
public:clx_sem(int num) {sem_init(&_sem, 0, num);}~clx_sem(){sem_destroy(&_sem);}void P(){sem_wait(&_sem);}void V(){sem_post(&_sem);}
private:sem_t _sem;
};

#include "clx_semaphore.hpp"
#include <pthread.h>#define THREAD_NUM 5clx_sem sem(1);
int ticket_count = 1000;void* Routine(void* arg) {char* msg = (char*)arg;while (true) {sem.P();if (ticket_count > 0) {usleep(1000);ticket_count -= 1;cout << msg << " get a ticket ," << " ticket_count = " << ticket_count << endl;sem.V();}else {sem.V();break;}}std::cout << msg << "quit ... " << std::endl;free(msg);return (void*)0;
}void semaphore_test() {// 创建5个线程模拟抢票动作pthread_t tids[THREAD_NUM];for (int i = 0; i < THREAD_NUM; i++) {char* buffer = (char*)malloc(64);sprintf(buffer, "thread %d", i);pthread_create(tids + i, NULL, Routine, (void*)buffer);}for (int i = 0; i < THREAD_NUM; i++){pthread_join(tids[i], NULL);}
}int main(){semaphore_test();return 0;
}

基于环形队列的生产消费模型

在生产者消费者模型中，生产者关注的是空间资源，消费者关注的是数据资源。我们可以使用信号量来描述环形队列中的空间资源和数据资源。

对于生产者来说，生产者每次生产数据前都需要先申请空间信号量，若空间信号量不为0，则申请成功，生产者可以进行生产操作。如果空间信号量值为0，则申请失败，生产者会被放入空间信号量的阻塞队列中进行等待，直到环形队列中有新的空间后再被唤醒
对于消费者来说，消费者每次消费数据前都需要先申请数据信号量，若数据信号量不为0，则申请陈工，消费者可以进行消费操作。如果数据信号量为0，则申请失败，消费者会被放入数据信号量的阻塞队列中进行等待，直到唤醒队列中有新的空间后再被唤醒

#pragma once 
#include <iostream>
#include <vector>
#include <semaphore.h>
#include <unistd.h>
using namespace std;#define QUEUE_CAPACITY 8template<typename T>
class RingQueue{
public:static RingQueue<T>* GetInstance(int _cap = QUEUE_CAPACITY);~RingQueue();void Push(const T& task);void Pop(T* task);
private:RingQueue(int _capacity);
private:static RingQueue<T>* instance;vector<T> rique;int capacity;int pro_pos;int con_pos;sem_t blank_sem;sem_t data_sem;
};template<typename T>
RingQueue<T>* RingQueue<T>::instance = nullptr;template<typename T>
RingQueue<T>* RingQueue<T>::GetInstance(int _cap) {if (instance == nullptr) {instance = new RingQueue<T>(_cap);}return instance;
}template<typename T>
RingQueue<T>::RingQueue(int _capacity) :capacity(_capacity), pro_pos(0), con_pos(0)
{rique.resize(_capacity, T());sem_init(&blank_sem, 0, _capacity);sem_init(&data_sem, 0, 0);
}template<typename T>
RingQueue<T>::~RingQueue() {sem_destroy(&blank_sem);sem_destroy(&data_sem);
} // 生产者向环形队列中插入数据
template<typename T>
void RingQueue<T>::Push(const T& task) {sem_wait(&blank_sem);rique[pro_pos] = task;sem_post(&data_sem);pro_pos += 1;pro_pos %= capacity;
}template<typename T>
void RingQueue<T>::Pop(T* task) {sem_wait(&data_sem);*task = rique[con_pos];sem_post(&blank_sem);con_pos += 1;con_pos %= capacity;
}

#include "RingQueue.h"
#include <pthread.h>
#include <time.h>void* Producer(void* arg) {RingQueue<int>* rq = (RingQueue<int>*)arg;while (true) {sleep(1);int data = rand() % 100 + 1;rq->Push(data);cout << "Producer: " << data << endl;}
}void* Consumer(void* arg){RingQueue<int>* rq = (RingQueue<int>*)arg;while (true) {sleep(1);int data = 0;rq->Pop(&data);cout << "Consumer " << data << endl;}
}int main(){srand((unsigned int)time(nullptr));pthread_t producer, consumer;RingQueue<int>* rq = RingQueue<int>::GetInstance(8);pthread_create(&producer, NULL, Producer, (void*)rq);pthread_create(&consumer, NULL, Consumer, (void*)rq);pthread_join(producer, NULL);pthread_join(consumer, NULL);delete rq;return 0;
}