【Linux】生产者消费者模型 - 详解

Hello_World_213

已于 2023-02-13 22:21:39 修改

阅读量1.2k

点赞数 3

分类专栏： Linux 文章标签： linux c++

于 2023-02-13 21:51:25 首次发布

本文链接：https://blog.csdn.net/Hello_World_213/article/details/129011092

版权

Linux 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

2.BlockingQueue.hpp - 阻塞队列类

3.LockGurad.hpp - RAII互斥锁类

4.Task.hpp - 在阻塞队列中生产/消费的任务类

3.CircularQueue.hpp - 环形队列类

4.LockGuard.hpp - RAII互斥锁类

一.生产者消费者模型概念

1.为何要使用生产者消费者模型

生产者消费者模式就是通过一个"容器"来解决生产者与消费者之间的强耦合问题, 生产者和消费者彼此之间不直接通讯, 而是通过特定"容器"来进行通讯, 所以生产者生产完数据之后不需要等待消费者处理, 直接扔给"容器", 消费者不直接找生产者索要数据, 而是从"容器"中拿数据, "容器"其实就是由特定的数据结构编写的缓冲区, 平衡了生产者和消费者的处理能力, 通过生产消费之间的"容器"达到解耦的目的

2.生产者消费者之间的关系

一个场所, 也就是上述"容器"

二个角色, 生产者与消费者

三种关系

生产者 - 生产者: 互斥关系

消费者 - 消费者: 互斥关系

生产者 - 消费者: 互斥关系, 同步关系

生产者消费者模型分为两种

1.单生产单消费

2.多生产多消费

3.生产者消费者模型的优点

1.将生产者消费者的强耦合关系解耦

2.支持并发

二.基于阻塞队列的生产消费模型

1.在阻塞队列中的三种关系

生产者与生产者之间互斥

消费者与消费者之间互斥

生产者与消费者之间既互斥又同步

同步关系使用条件变量

2.BlockingQueue.hpp - 阻塞队列类

#pragma once

#include <iostream>
#include <queue>
#include "LockGurad.hpp"

template <class T>
class BlockingQueue
{
public:
    static BlockingQueue<T> *GetInst()
    {
        return &_sInst;
    }

public:
    void push(const T& in)
    {
        LockGurad lock(&_mutex); // RAII锁
        // 如果阻塞队列满了就阻塞
        while(isFull())
        {
            pthread_cond_wait(&_isFullCond, &_mutex); // 已满, 阻塞
        }
        _bq.push(in);
        pthread_cond_signal(&_isEmptyCond); // 已经添加了一个, 唤醒已空条件阻塞
    }

    void pop(T* out)
    {
        LockGurad lock(&_mutex); // RAII锁
        // 如果阻塞队列空了就阻塞
        while(isEmpty())
        {
            pthread_cond_wait(&_isEmptyCond, &_mutex); // 已空, 阻塞
        }
        *out = _bq.front();
        _bq.pop();
        pthread_cond_signal(&_isFullCond); // 已经取走了一个, 唤醒已满条件阻塞
    }

    ~BlockingQueue()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_isFullCond);
        pthread_cond_destroy(&_isEmptyCond);
    }

private:
    bool isFull() // 判满
    {
        return _bq.size() == _capacity;
    }

    bool isEmpty() // 判空
    {
        return _bq.size() == 0;
    }

private:
    std::queue<T> _bq;          // 阻塞队列
    size_t _capacity;           // 阻塞队列最大容量
    pthread_mutex_t _mutex;      // 保护阻塞队列的锁
    pthread_cond_t _isFullCond;  // 判断是否为满
    pthread_cond_t _isEmptyCond; // 判断是否为空

private:
    // 单例模式
    BlockingQueue(size_t capacity = 5) : _capacity(capacity)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_isFullCond, nullptr);
        pthread_cond_init(&_isEmptyCond, nullptr);
    }
    BlockingQueue(const BlockingQueue<T> &copy) = delete;
    BlockingQueue<T> &operator=(const BlockingQueue<T> &copy) = delete;

    static BlockingQueue<T> _sInst;
};

template <class T>
BlockingQueue<T> BlockingQueue<T>::_sInst;

3.LockGurad.hpp - RAII互斥锁类

#pragma once

#include <pthread.h>

class LockGurad
{
public:
    LockGurad(pthread_mutex_t* mutex):_mutex(mutex)
    {
        pthread_mutex_lock(_mutex);
    }

    ~LockGurad()
    {
        pthread_mutex_unlock(_mutex);
    }

private:
    pthread_mutex_t* _mutex;
};

4.Task.hpp - 在阻塞队列中生产/消费的任务类

#pragma once

typedef int(* func_t)(int, int);

struct Task
{
    Task(){};
    Task(int x, int y, func_t func):_x(x),_y(y),_func(func)
    {}

    int operator()()
    {
        return _func(_x, _y);
    }

    int _x;
    int _y;

    func_t _func;
};

5.CPTest.cc - 测试

#include "BlockingQueue.hpp"
#include "Task.hpp"
#include "time.h"
#include "stdlib.h"
#include "sys/types.h"
#include "unistd.h"

int myAdd(int x, int y)
{
    return x + y;
}

void *Consumer(void *args)
{
    BlockingQueue<Task> *bqsInst = (BlockingQueue<Task> *)args;

    while (1)
    {
        // 消费任务
        Task t;
        bqsInst->pop(&t);

        std::cout << pthread_self() << " consumer: " << t._x << "+" << t._y << "=" << t() << std::endl;
        sleep(1);
    }

    return nullptr;
}

void *Provider(void *args)
{
    BlockingQueue<Task> *bqsInst = (BlockingQueue<Task> *)args;

    while (1)
    {
        // 制作任务
        int x = rand() % 100 + 1;
        int y = rand() % 100 + 1;
        Task t(x, y, myAdd);

        // 添加任务
        bqsInst->push(t);

        std::cout << pthread_self() << " productor: " << t._x << "+" << t._y << "=?" << std::endl;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    srand((unsigned int)time(nullptr) ^ getpid() ^ 0x123);

    // 获取单例指针
    BlockingQueue<Task> *bqsInst = BlockingQueue<Task>::GetInst();

    // 单生产单消费
    //pthread_t c, p;
    //pthread_create(&c, nullptr, Consumer, bqsInst);
    //pthread_create(&p, nullptr, Provider, bqsInst);

    // 多生产多消费
    pthread_t c[2], p[3];
    pthread_create(c, nullptr, Consumer, bqsInst);
    pthread_create(c + 1, nullptr, Consumer, bqsInst); 

    pthread_create(p, nullptr, Provider, bqsInst);
    pthread_create(p + 1, nullptr, Provider, bqsInst);
    pthread_create(p + 2, nullptr, Provider, bqsInst);

    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);

    return 0;
}

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

数据结构: 环形队列, 传送入口: http://t.csdn.cn/p1OXv

1.在环形队列中的三种关系

生产者与生产者之间互斥

消费者与消费者之间互斥

生产者与消费者之间同步

同步关系使用信号量

生产消费不需要互斥, 即分别用两把锁

2.环形队列vs阻塞队列

环形队列对比阻塞队列的优势: 生产与消费可以同时进行, 这是因为环形数据结构的特性, 以及信号量sem共同支持的

为什么?

对于阻塞队列而言

当阻塞队列中还存在有数据时, 生产者与消费者必然不会访问到同一个数据, 但是当队列为空, 如果不将生产与消费互斥的话, 就很可能在生产的同时又在消费, 消费的可能是正在生产中的数据, 就可能发生问题

对于环形队列而言

生产者与消费者的下标, 只有在环形队列满或空时指向同一位置, 通过信号量进行同步之后, 不可能会发生同时在同一位置生产消费的情况

生产消费指向同一位置, 只有两种情况

1.环形队列为满, 此时该位置是还存有未消费的数据, 没有多余的生产信号量, 该位置只可能存在消费行为

2.环形队列为空, 此时该位置不存有任何数据, 没有多余的消费信号量, 该位置只可能存在生产行为