【Linux】信号量

信号量也是线程的一种同步机制，本质上是一个整型计数器。

初始化信号量：

int sem_init(sem_t *sem, int pshared, unsigned int value);
参数：
pshared：0表示线程间共享，非零表示进程间共享
value：信号量初始值

销毁信号量：

int sem_destroy(sem_t *sem);

等待信号量：

int sem_wait(sem_t *sem); //也叫P()
功能：等待信号量，会将信号量的值减1
若计数器等于 0，则线程阻塞，直到其他线程释放资源

发布信号量：

int sem_post(sem_t *sem);	//也叫V()
功能：发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加1。
若有线程在等待，系统会唤醒一个等待的资源（上面wait中）。

现在使用循环队列来演示生产者-消费者模型：
RingQueue.hpp：

#pragma once
#include <iostream>
#include <vector>
#include <string>
#include <semaphore.h>
#include <pthread.h>

template<typename T>
class RingQueue
{
private:
    void P(sem_t &s)
    {
        sem_wait(&s);   //等待信号量
    }
    void V(sem_t &s)
    {
        sem_post(&s);   //发布信号量
    }
public:
    RingQueue(int max_cap)
        :_ringqueue(max_cap), _max_cap(max_cap), _c_step(0), _p_step(0)
    {
        //初始化信号量
        sem_init(&_data_sem, 0, 0);    //数据量为0
        sem_init(&_space_sem, 0, _max_cap);    //空间量满的

        pthread_mutex_init(&_c_mutex, nullptr);
        pthread_mutex_init(&_p_mutex, nullptr);
    }
    void Push(const T &in)  //生产者放入
    {
        P(_space_sem);  //生产者放入数据，所以循环队列空间减一
        //确定有位置再加锁，而不是加了锁之后发现没有位置然后就阻塞
        //此时仍持有锁，而其他线程就无法获取锁
        pthread_mutex_lock(&_p_mutex);   
        _ringqueue[_p_step] = in;
        _p_step++;
        _p_step %= _max_cap;
        pthread_mutex_unlock(&_p_mutex);
        V(_data_sem);   //数据加一
    }
    void Pop(T *out)    //消费
    {
        P(_data_sem);   //尝试获取数据，没有就阻塞
        pthread_mutex_lock(&_c_mutex);
        *out = _ringqueue[_c_step]; //获取数据
        _c_step++;
        _c_step %= _max_cap;
        pthread_mutex_unlock(&_c_mutex);
        V(_space_sem);  //上面消费者获取数据后，空间加一
    }
    ~RingQueue()
    {
        sem_destroy(&_data_sem);
        sem_destroy(&_space_sem);

        pthread_mutex_destroy(&_c_mutex);
        pthread_mutex_destroy(&_p_mutex);
    }

private:
    std::vector<T> _ringqueue;
    int _max_cap;   //最大容量

    int _c_step;    //消费者指向的位置
    int _p_step;    //生产者指向的位置

    sem_t _data_sem;    //所剩数据的信号量-消费者取数据
    sem_t _space_sem;   //所剩空间的信号量-生产者产数据

    pthread_mutex_t _c_mutex;   //消费者的锁，管理消费者之间的关系
    pthread_mutex_t _p_mutex;   //生产者的锁，管理生产者之间的关系
};

Task.hpp：

#pragma once
#include <string>

class Task
{
public:
    Task()
    {

    }
    Task(int x, int y):_x(x), _y(y)
    {}
    void Excute()
    {
        _result = _x + _y;
    }

    std::string Result()
    {
        std::string msg = std::to_string(_x) + "+" + std::to_string(_y) + "=" + std::to_string(_result);
        return msg;
    }

    std::string debug()
    {
        std::string msg = std::to_string(_x) + "+" + std::to_string(_y) + "=?";
        return msg;
    }
private:
    int _x;
    int _y;
    int _result;
};

Main.cc:

#include "RingQueue.hpp"
#include "Task.hpp"
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include <random>

void *consumerFunc(void *args)
{
    RingQueue<Task> *rq = static_cast<RingQueue<Task> *>(args);
    while (true)
    {
        Task t;
        rq->Pop(&t);    //取数据
        t.Excute();     //执行
        std::cout << "consumer -> " << t.Result() << std::endl;
    }
}

void *producerFunc(void *args)
{
    RingQueue<Task> *rq = static_cast<RingQueue<Task> *>(args);
    while (true)
    {
        sleep(1);
        int x = rand() % 10 + 1; //1~10
        usleep(x*1000);
        int y = rand() % 20 + 1; //1~20
        Task t(x, y);
        rq->Push(t);    //存数据
        std::cout << "producer -> " << t.debug() << std::endl;
    }
    
    
}

int main()
{
    srand(time(nullptr) ^ getpid());
    RingQueue<Task> *rq = new RingQueue<Task>(5);
    pthread_t consumer1, consumer2, producer1, producer2;
    pthread_create(&consumer1, nullptr, consumerFunc, rq);
    pthread_create(&consumer2, nullptr, consumerFunc, rq);
    pthread_create(&producer1, nullptr, producerFunc, rq);
    pthread_create(&producer2, nullptr, producerFunc, rq);

    pthread_join(consumer1, nullptr);
    pthread_join(consumer2, nullptr);
    pthread_join(producer1, nullptr);
    pthread_join(producer2, nullptr);
    return 0;
}