【linux】基于环形队列的生产者消费者模型（信号量）

一、引入

前面我们讲过使用条件变量实现生产者消费者模型【linux】基于阻塞队列的生产者消费者模型（条件变量）。
我们可以看到它的不足之处：

我们使用线程操作临界资源的时候要先判断临界资源是否满足条件，而我们并不能事先得知，我们只能先加锁判断、再操作、再解锁。
那么我们有没有一种办法能够提前得知是否满足条件呢？
答案是有，靠信号量实现。

二、信号量

2.1 信号量的概念

现在有一块临界资源，一个线程可能只会访问它的其中1/100的资源，所以能允许多个线程同时访问不同的区域。

信号量就相当于一个计数器（衡量临界资源还有多少的计数器）。

就像看电影的时候，我们要进入电影院之前先得买票，只要有了票就说明了那个座位就属于自己的了。类比到线程，线程申请一个信号量，如果成功那么一定有一个位置给该进程预留着。
这这里的多个线程并发访问公共资源的不同区域是由程序员编码实现的。

有了信号量，我们在真正的访问临界资源之前就知道临界资源的使用情况。

一句话总结：
只要申请成功就一定会有资源，申请失败说明条件不就绪就只能等待。所以就不需要再判断了。

2.2 信号量的PV操作

当线程想要访问临界资源的某一区域时，就要先申请信号量，既然每个线程都要看到这个信号量，那么信号量就一定是公共资源，而上面我们说了信号量本质上是一个计数器，所以需要加减操作。为了保证线程安全所以加减也要保证原子性（PV原语）。

P：

sem–，申请资源

V：

sem++，释放资源

2.3 信号量接口

2.3.1 信号量初始化sem_init

#include 

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

Link with -pthread.

参数说明：

sem：自己定义的信号量变量。
pshared：0表示线程间共享，非零表示进程间共享。
value：信号量初始值(资源数目)。

2.3.2 信号量销毁sem_destroy

#include 

int sem_destroy(sem_t *sem);

Link with -pthread.

2.3.3 信号量等待sem_wait§

int sem_wait(sem_t *sem);

等待信号量，会将信号量的值减1

2.3.4 信号量发布sem_post(V)

int sem_post(sem_t *sem);

发布信号量，表示资源使用完毕，可以归还资源了。将信号量值加1。

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

3.1 引入环形队列

环状队列在之前的文章中有过详细介绍及代码实现：一万字彻底学会栈和队列
它实际上不是一个真正的环形，而是由数组模拟实现的，当加过最后的位置的时候直接膜数组的大小即可。
当时判断空满的问题我们采取的方式是空出一个位置，当两个指针指向同一个地方的时候就是空，当只剩一个位置的时候就是满。但是在这里根本不需要我们关注空满。

3.2 环形队列的访问

有两种情况生产者和消费者会访问同一个位置，一种为空，一种为满。
其他情况生产者和消费者访问的就是不同的区域。

这里消费者和生产者要有一定的规则：

1️⃣ 消费者不能超过生产者（无数据可消费）。
2️⃣ 生产者不能把消费者套一个圈以上（数据覆盖）。
3️⃣ 当消费者和生产者指向同一个位置的时候，如果是满就让消费者先走，如果是空就让生产者先走。

所以在大部分的情况下生产者和消费者是并发执行的。 只有在满与空的时候才会有同步与互斥的问题。

而为了保证这些规则，我们就要用到信号量。

对于消费者，只关心剩多少资源
对于生产者，只关心剩多少空位

所以我们需要两个信号量维护。

比方说我们设置有10个空位置，初始的时候消费者的信号量就是0，生产者的信号量就为10。

当生产者线程要生产数据的时候，申请信号量，如果成功进行P操作，信号量变为9；如果失败执行流就阻塞在申请处。而申请成功后，消费者的看到的资源就会多了一个，所以要把消费者的信号量V操作。

当消费者消费的时候同理，失败则阻塞，成功就让消费者的信号量P操作，然后再把生产者的信号量V操作。

所以为什么我们不用判断空满呢？因为当生产者生产满了，就申请不到了，之能等消费者先走；消费者同理。

3.3 代码实现

//RingQueue.hpp
#pragma once

#include 
#include 
#include 

using std::cout;
using std::endl;

const int Cap = 10;// 环形队列大小

template <class T>
class RingQueue
{
private:
    // PV操作
    void P(sem_t& sem)
    {
        sem_wait(&sem);
    }

    void V(sem_t& sem)
    {
        sem_post(&sem);
    }

public:
    RingQueue(const int& cap = Cap)
        : _que(cap)
    {
        sem_init(&_csem, 0, 0);
        sem_init(&_psem, 0, cap);
    }

    void push(const T& in)
    {
        P(_psem);
        _que[_productoridx++] = in;
        _productoridx %= _que.size();
        V(_csem);
    }

    void pop(T* out)
    {
        P(_csem);
        *out = _que[_consumeridx++];
        _consumeridx %= _que.size();
        V(_psem);
    }

    ~RingQueue()
    {
        sem_destroy(&_csem);
        sem_destroy(&_psem);
    }

private:
    std::vector<T> _que;
    sem_t _psem;// 生产者信号量，空间资源
    sem_t _csem;// 消费者信号量， 数据资源
    int _productoridx = 0;
    int _consumeridx = 0;
};

// Main.cc
#include "RingQueue.hpp"

#include 
#include 
#include 
#include 
#include 

void* ProductorHandler(void* rq)
{
    RingQueue<int>* prq = static_cast<RingQueue<int>*>(rq);
    while(true)
    {
        int val = rand() % 100;
        prq->push(val);
        printf("生产数据: %d\n", val);
        //sleep(1);
    }
}

void* ConsumerHandler(void* rq)
{
    RingQueue<int>* prq = static_cast<RingQueue<int>*>(rq);
    while(true)
    {
        int val;
        prq->pop(&val);
        printf("消费数据: %d\n", val);
        sleep(1);
    }
}

int main()
{
    srand((unsigned int)time(nullptr));
    RingQueue<int>* rq = new RingQueue<int>();
    pthread_t p, c;
    pthread_create(&p, nullptr, ProductorHandler, rq);
    pthread_create(&c, nullptr, ConsumerHandler, rq);

    pthread_join(p, nullptr);
    pthread_join(c, nullptr);
    delete rq;
    return 0;
}

这里重要的就是进队列出队列操作。

void push(const T& in)
{
    P(_psem);
    _que[_productoridx++] = in;
    _productoridx %= _que.size();
    V(_csem);
}

void pop(T* out)
{
    P(_csem);
    *out = _que[_consumeridx++];
    _consumeridx %= _que.size();
    V(_psem);
}

两个信号量都需要修改。

四、环形队列的应用

我们把上一章节写的计算小任务拿过来，让环形队列里放的是任务。

// Task.hpp
#pragma once

#include 
#include 
#include 
#include 
#include 

class Task
{
    typedef std::function<int(int, int, char)> func_t;
public:
    Task()
    {}

    Task(int x, int y, char op, func_t func)
        : _x(x)
        , _y(y)
        , _op(op)
        , _func(func)
    {}

    std::string operator()()
    {
        int res = _func(_x, _y, _op);
        char buf[64];
        snprintf(buf, sizeof buf, "%d %c %d = %d", _x, _op, _y, res);
        return buf;
    }
private:
    int _x;
    int _y;
    char _op; 
    func_t _func;
};

const std::string oper = "+-*/";

std::unordered_map<char, std::function<int(int, int)>> hash = {
        {'+', [](int x, int y)->int{return x + y;}},
        {'-', [](int x, int y)->int{return x - y;}},
        {'*', [](int x, int y)->int{return x * y;}},
        {'/', [](int x, int y)->int{
            if(y == 0)
            {
                std::cerr << "除0错误" << endl;
                return -1;
            }
            return x / y;}},
    };

int myMath(int x, int y, char op)
{
    int res = hash[op](x, y);
    return res;
}

// Main.cc
#include "RingQueue.hpp"
#include "Task.hpp"
#include 
#include 
#include 
#include 
#include 

void* ProductorHandler(void* rq)
{
    RingQueue<Task>* prq = static_cast<RingQueue<Task>*>(rq);
    while(true)
    {
        int x = rand() % 100;
        int y = rand() % 10;
        int opidx = rand() % 4;
        Task t(x, y, oper[opidx], myMath);
        prq->push(t);
        printf("生产任务: %d %c %d = ?\n", x, oper[opidx], y);
        //sleep(1);
    }
}

void* ConsumerHandler(void* rq)
{
    RingQueue<Task>* prq = static_cast<RingQueue<Task>*>(rq);
    while(true)
    {
        Task t;
        prq->pop(&t);
        cout << "消费任务" << t() << endl;
        sleep(1);
    }
}

int main()
{
    srand((unsigned int)time(nullptr));
    RingQueue<Task>* rq = new RingQueue<Task>();
    pthread_t p, c;
    pthread_create(&p, nullptr, ProductorHandler, rq);
    pthread_create(&c, nullptr, ConsumerHandler, rq);

    pthread_join(p, nullptr);
    pthread_join(c, nullptr);
    delete rq;
    return 0;
}

五、总结

1️⃣ 信号量和条件变量有什么不同呢？

它们俩的应用场景不一样，当我们需要每一刻都只能有一个资源访问临界资源的时候（互斥），就可以用条件变量。
当我们想让多个线程并发的访问一块临界资源的不同区域的时候就可以用信号量。

2️⃣ 我们今天介绍的是单生产和单消费的情况，如果是多生产多消费的情况呢？

上一章是只能允许一个消费者或者一个生产者能进入阻塞队列，而这里就是能允许一个消费者和一个阻塞队列同时进入阻塞队列，多消费就让多个消费者互斥（在push和pop中加锁），竞争出一个线程，生产者同理。

---

---