【Linux】生产者和消费者模型

生产者和消费者概念

生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。

生产者和消费者彼此之间不直接通讯，而通过这个容器来通讯，所以生产者生产完数据之后不用等待消费者处理，直接将生产的数据放到这个容器当中，消费者也不用找生产者要数据，而是直接从这个容器里取数据，这个容器就相当于一个缓冲区，平衡了生产者和消费者的处理能力，这个容器实际上就是用来给生产者和消费者解耦的。

生产者消费者模型的特点

生产者消费者模型是多线程同步与互斥的一个经典场景，其特点如下：

• 三种关系： 生产者和生产者（互斥关系）、消费者和消费者（互斥关系）、生产者和消费者（互斥关系、同步关系）。
• 两种角色： 生产者和消费者。（通常由进程或线程承担）
• 一个交易场所： 通常指的是内存中的一段缓冲区。（可以自己通过某种方式组织起来）

生产者和生产者、消费者和消费者、生产者和消费者，它们之间为什么会存在互斥关系？

因为在生产者和消费者之间存在多种执行流同时访问的问题，，因此我们需要将他们同时访问的临界区进行加互斥保护起来
其中，所有的生产者和消费者都会竞争式的申请锁，因此生产者和生产者、消费者和消费者、生产者和消费者之间都存在互斥关系。

生产者和消费者之间为什么会存在同步关系？

• 如果让生产者一直生产，那么当生产者生产的数据将容器塞满后，生产者再生产数据就会生产失败。
• 反之，让消费者一直消费，那么当容器当中的数据被消费完后，消费者再进行消费就会消费失败。

虽然这样不会造成任何数据不一致的问题，但是这样会引起另一方的饥饿问题，是非常低效的。我们应该让生产者和消费者访问该容器时具有一定的顺序性，比如让生产者先生产，然后再让消费者进行消费。

• 注意： 互斥关系保证的是数据的正确性，而同步关系是为了让多线程之间协同起来。

基于BlockingQueue的生产者消费者模型

当多个生产者，消费者同时出现进行抢占线程时，我们可以使用BlockingQueue来进行缓冲，如图

其与普通的队列的区别在于：

• 当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中放入了元素。
• 当队列满时，往队列里存放元素的操作会被阻塞，直到有元素从队列中取出。

知识联系： 看到以上阻塞队列的描述，我们很容易想到的就是管道，而阻塞队列最典型的应用场景实际上就是管道的实现。

put为生产者，take为消费者

全部代码

task.hpp 用于实现打印和计算

#pragma once
#include 
#include 

class Task
{
public:
    Task(){}
    Task(int x,int y,char op):_x(x),_y(y),_op(op),_result(0),_exitCode(0)
    {}

    void operator()()
    {
        switch(_op)
        {
            case '+' :
                _result = _x + _y;
                break;
            case '-':
            _result = _x - _y;
            break;
        case '*':
            _result = _x * _y;
            break;
        case '/':
        {
            if (_y == 0)
                _exitCode = -1;
            else
                _result = _x / _y;
        }
        break;
        case '%':
        {
            if (_y == 0)
                _exitCode = -2;
            else
                _result = _x % _y;
        }
        break;

        default:
            break;
        }
    }
    std::string formatArg()
    {
        return std::to_string(_x) + _op + std::to_string(_y) + "="; 
    }

    std::string formatRes()
    {
        return std::to_string(_result) + "(" + std::to_string(_exitCode) + ")";
    }

    ~Task()
    {}
private:
    int _x;
    int _y;
    char _op;//输入的符号

    int _result;
    int _exitCode;
};

blockQueue.hpp 维护线程之间的同步

#pragma once 
#include 
#include 
#include 

const int gcap = 5;//最大容量
template<class T>
class BlockQueue
{
public:
    BlockQueue(const int cap = gcap):_cap(gcap)
    {
        pthread_mutex_init(&_mutex,nullptr);//初始化互斥量

        //初始化用户和生产者的条件变量
        pthread_cond_init(&_consumerCond,nullptr);
        pthread_cond_init(&_consumerCond,nullptr);
    }


    //判断是否为慢
    bool isFull()
    {
        return _q.size() == _cap;
    }

    //判断是否为空
    bool isEmpty()
    {
        return _q.empty();
    }

    //插入
    void push(const T &in)
    {
        pthread_mutex_lock(&_mutex);
        //细节1：一定要保证，在任何时候，都要符合条件，才进行生产
        while(isFull())
        {
            //1 我们只能在临界区内部，判断临界区资源是否就绪！注定了我们在当前一定持有锁。
            //2 要让线程进行休眠等待，不能持有锁等待
            //3 注定了pthread_cond_wait要有锁的释放能力
            pthread_cond_wait(&_productCond,&_mutex);
            // 4. 当线程醒来的时候，注定了继续从临界区内部继续运行！因为我是在临界区被切走的！
            // 5. 注定了当线程被唤醒的时候，继续在pthread_cond_wait函数出向后运行，又要重新申请锁，申请成功才会彻底返回
        }

        // 没有满，就要让他继续运行
        _q.push(in);

        //加策略
        pthread_cond_signal(&_consumerCond);
        pthread_mutex_unlock(&_mutex);
    }

    //取出删除
    void pop(T* out)
    {
        pthread_mutex_lock(&_mutex);
        while(isEmpty()) 
        {
            pthread_cond_wait(&_consumerCond, &_mutex);
        }
        *out = _q.front();
        _q.pop();
        // 加策略
        pthread_cond_signal(&_productCond);
        pthread_mutex_unlock(&_mutex);
    }

    ~BlockQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_consumerCond);
        pthread_cond_destroy(&_productCond);
    }
private:
    std::queue<T> _q;
    int _cap;//生产容量
    //为什么我们这份代码只有一个锁，根本原因在于
    //我们生产者和消费者访问的是同一个queue && queue 被当作整体使用
    pthread_mutex_t _mutex;
    pthread_cond_t _consumerCond;//消费者对应的条件变量
    pthread_cond_t _productCond;//生产者对应的条件变量
};

main.cc

#include 
#include "task.hpp"
#include "blockQueue.hpp"
#include 
#include 
#include 

void* consumer(void* args)
{
    BlockQueue<Task>* bq = static_cast<BlockQueue<Task>*>(args);

    while(1)
    {
        Task t;
        // 1. 将数据从blockqueue中获取 -- 获取到了数据
        bq->pop(&t);
        t();
        // 2. 结合某种业务逻辑，处理数据！ -- TODO
        std::cout << pthread_self() << " | consumer data: " << t.formatArg() << t.formatRes() << std::endl;
    }
}

void *productor(void *args)
{
    BlockQueue<Task> *bq = static_cast<BlockQueue<Task> *>(args);
    std::string opers = "+-*/%";
    while(1)
    {
        int x = rand()%20 +1;
        int y = rand()%20 +1;

        char op = opers[rand() % opers.size()];

        Task t(x,y,op);
        bq->push(t);
        std::cout << pthread_self() << " | productor Task: " <<  t.formatArg() << "?" << std::endl;
    }
}

int main()
{
    BlockQueue<Task>*bq = new BlockQueue<Task>();
    pthread_t c[2], p[3];
    pthread_create(&c[0], nullptr, consumer, bq);
    pthread_create(&c[1], nullptr, consumer, bq);
    pthread_create(&p[0], nullptr, productor, bq);
    pthread_create(&p[1], nullptr, productor, bq);
    pthread_create(&p[2], nullptr, productor, bq);

    pthread_join(c[0], nullptr);
    pthread_join(c[1], nullptr);
    pthread_join(p[0], nullptr);
    pthread_join(p[1], nullptr);
    pthread_join(p[2], nullptr);
    delete bq;
    return 0;
    return 0;
}