【Linux】POSIX 信号量

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 5

clx_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 8


template<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;
}

参考文章「2021dragon」的原创文章信号量
原文链接：https://blog.csdn.net/chenlong_cxy/article/details/123167179