生产消费者(CP)模型

CP模型有三个部分:productor和consumer(由线程组成的功能块)还有一个特定结构的内存空间

以超市为例,超市货物由供应商提供,超市暂时存储货物,消费者可以在超市购买货物。

工作流程;生产者获取数据,生产任务并将任务放到仓库,消费者从仓库获取任务,处理任务


"321"原则

三种关系:

生产者和生产者之间的关系:互斥

消费者和消费者之间的关系:互斥

生产者和消费者之间的关系:互斥,同步(必须生产者生产之后,消费者才能消费,要有顺序)

**二种角色:**生产和消费

**一个交易所:**特定的内存结构空间


优点:

1.支持忙闲不均,如果仓库为满,生产者可以不生产一段时间,消费者可以一直消费

2.生产和消费解耦合,因为有仓库作缓冲

3.提高效率:在生产者获取数据和生产任务的时候,消费者可以处理数据,二者可以同时进行;生产者和消费者是多线程,多个线程同时完成获取数据和处理任务的工作。


代码模拟:

cpp 复制代码
//block_queue.hpp
#include <queue>
#include <mutex>
#include <condition_variable>

#define MAX_CAPACITY 100
template <class T>
class blockqueue
{
public:
    std::queue<T> q;
    int max_capcity = MAX_CAPACITY; // 最大存储数量
    std::mutex pmut;                // 生产者锁
    std::mutex cmut;                // 消费者锁
    std::condition_variable pcon;
    std::condition_variable ccon;
    blockqueue()
    {
    }
    ~blockqueue()
    {
    }

    void push(T &task);
    void pop();
    bool empty();
    size_t size();
    T front();
};

template<class T>
void blockqueue<T>::push(T &task)
{
    q.push(task);
}

template<class T>
void blockqueue<T>::pop()
{
    q.pop();
}

template<class T>
bool blockqueue<T>::empty()
{
    return q.empty();
}

template<class T>
size_t blockqueue<T>::size()
{
    return q.size();
}

template<class T>
T blockqueue<T>::front()
{
    return q.front();
}
cpp 复制代码
//main.cpp
#include <iostream>
#include <ctime>
#include <thread>
#include <unistd.h>
#include "block_queue.hpp"

using namespace std;

void product(blockqueue<string> &bq)
{
    unique_lock<mutex> ul(bq.pmut);
    while (1)
    {
        //获取数据
        int n = rand() % 10000;
        cout << "获取数据:" << to_string(n) << endl;
        sleep(1);
        while (bq.size() >= bq.max_capcity)
        {
            // 不使用if,因为可能造成伪唤醒
            cout << "任务已满,等待" << endl;
            bq.pcon.wait(ul);
        }
        cout << "生成任务" << endl;
        string name = "task" + to_string(n);
        bq.push(name);
        bq.ccon.notify_all();
        sleep(1);
    }
}

void consume(blockqueue<string> &bq)
{
    unique_lock<mutex> ul(bq.cmut);
    while (1)
    {
        while (bq.empty())
        {
            cout << "没有任务,等待" << endl;
            bq.ccon.wait(ul);
        }
        //获取任务
        string name = bq.front();
        cout << "get " << name << endl;
        bq.pop();
        bq.pcon.notify_all();
        //sleep(1);
        //处理任务
        cout << "处理数据中。。。" << endl; 
        //sleep(1);
    }
}

int main()
{
    srand(time(nullptr));
    blockqueue<string> bq;
    //生产者消费者都可以由多个线程组成
    thread p[10];
    for(auto& e:p)
    {
        e = thread(product, ref(bq));
    }
    thread c[5];
    for(auto& e:c)
    {
        e = thread(consume, ref(bq));
    }
    
    sleep(1);
    for(auto& e:p)
    {
        e.join();
    }
    for(auto& e:c)
    {
        e.join();
    }
    

    return 0;
} 

blockqueue<string>对象bq需要在多个线程之间共享,并且需要通过引用传递。使用std::ref可以确保这一点

相关推荐
牧以南歌〆1 小时前
在Ubuntu主机中修改ARM Linux开发板的根文件系统
linux·arm开发·驱动开发·ubuntu
xiaolang_8616_wjl2 小时前
c++文字游戏_闯关打怪2.0(开源)
开发语言·c++·开源
夜月yeyue2 小时前
设计模式分析
linux·c++·stm32·单片机·嵌入式硬件
kfepiza3 小时前
Debian的`/etc/network/interfaces`的`allow-hotplug`和`auto`对比讲解 笔记250704
linux·服务器·网络·笔记·debian
无小道3 小时前
c++-引用(包括完美转发,移动构造,万能引用)
c语言·开发语言·汇编·c++
cuijiecheng20184 小时前
Ubuntu下布署mediasoup-demo
linux·运维·ubuntu
FirstFrost --sy5 小时前
数据结构之二叉树
c语言·数据结构·c++·算法·链表·深度优先·广度优先
Tanecious.5 小时前
C++--map和set的使用
开发语言·c++
Yingye Zhu(HPXXZYY)5 小时前
Codeforces 2021 C Those Who Are With Us
数据结构·c++·算法
独行soc5 小时前
2025年渗透测试面试题总结-2025年HW(护网面试) 33(题目+回答)
linux·科技·安全·网络安全·面试·职场和发展·护网