生产者消费者模型 C++ 版

已于 2023-08-23 11:19:41 修改
阅读量953 收藏 4
点赞数
分类专栏： C++ 文章标签： c++ 算法
于 2023-08-10 11:26:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyouzhiyi/article/details/132189838
版权

基础生产者消费者模型

网上一般教程是使用std::queue,定义消费者 Consumer ，定义Producter类，在main函数里面加锁保证线程安全。
本片文章，实现一个线程安全的队列 threadsafe_queue，只在队列内部加锁。如此可适配，多生产者多消费者的场景

线程安全的队列 threadsafe_queue

#pragma once
#include<mutex>
#include <condition_variable>
#include<queue>
//最大产品数量
#define MAX_SIZE 20
#include <iostream>
template<typename T>
class threadsafe_queue
{
private:
    mutable std::mutex mut;
    std::queue<T> data_queue;
    std::condition_variable data_cond;
public:
    threadsafe_queue()
    {}
    
    void wait_and_pop(T& value)  // 2
    {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this]{return !data_queue.empty(); });
        value = std::move(data_queue.front());
        data_queue.pop();
        std::cout << "Consumer pop : " << value << std::endl;
        data_cond.notify_all();
    }
    std::shared_ptr<T> wait_and_pop()  // 3
    {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this]{return !data_queue.empty(); });  // 4
        std::shared_ptr<T> res(
            std::make_shared<T>(std::move(data_queue.front())));
        data_queue.pop();
        data_cond.notify_all();
        return res;
    }
    bool try_pop(T& value)
    {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return false;
        value = std::move(data_queue.front());
        data_queue.pop();
        data_cond.notify_all();
        return true;
    }
    std::shared_ptr<T> try_pop()
    {
        std::lock_guard<std::mutex> lk(mut);
        if (data_queue.empty())
            return std::shared_ptr<T>();  // 5
        std::shared_ptr<T> res(
            std::make_shared<T>(std::move(data_queue.front())));
        data_queue.pop();
        data_cond.notify_all();
        return res;
    }
    void push(T new_value)
    {
        std::unique_lock<std::mutex> lk(mut);
        data_cond.wait(lk, [this] {return data_queue.size() < MAX_SIZE; });
        std::cout << "Producter push : " << new_value << std::endl;
        data_queue.push(std::move(new_value));

        data_cond.notify_all();  // 1
    }
    bool empty() const
    {
        std::lock_guard<std::mutex> lk(mut);
        return data_queue.empty();
    }
};

消费者

Consumer 头文件

#pragma once
#include"threadsafe_queue.h"
/*
基础版 消费者生产者模型
此文件为 消费者
*/

class Consumer
{
public:
	Consumer(threadsafe_queue<int>& queue);
	~Consumer();
	void start();

private:
	threadsafe_queue<int>& m_pQueue;
};

cpp文件

#include "Consumer.h"
#include <iostream>
#include<windows.h>
Consumer::Consumer(threadsafe_queue<int> &queue)
	: m_pQueue(queue)
{

}

Consumer::~Consumer()
{
}


void Consumer::start()
{
	while (true)
	{
		int value;
		m_pQueue.wait_and_pop(value);
		Sleep(10);
	}
}

生产者

#pragma once
#include"threadsafe_queue.h"
class Producter
{
public:
	Producter(threadsafe_queue<int>& queue,int i);
	~Producter();
	void start();

private:
	threadsafe_queue<int>& m_pQueue;
	int index;
};
#include "Producter.h"
#include<stdlib.h>
#include <iostream>
#include<windows.h>
Producter::Producter(threadsafe_queue<int>& queue, int i)
	: m_pQueue(queue),index(i)
{

}

Producter::~Producter()
{
}


void Producter::start()
{
	int i = 0;//为了测试是哪个线程，加入了哪些数据用的
	while (true)
	{
		//int data = rand();
		m_pQueue.push(i*2+ index);// index =0 为偶数生产者，只生产偶数，index =1则是生产奇数
		Sleep(100);
		i++;
	}
}

运行结果如下：
在这里插入图片描述

控制消费者有序消费

优先队列做缓存
头文件

#pragma once
#include<mutex>
#include <condition_variable>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>

//最大产品数量
#define MAX_SIZE 20
/*


*/
template<typename T, class _Container = std::vector<T>, class _Pr = std::less<typename _Container::value_type>>
class threadsafe_priority_queue
{
public:
    threadsafe_priority_queue();
    ~threadsafe_priority_queue();

    void push(T new_value);
    bool empty() const;

    void wait_and_pop(T& value);

    std::shared_ptr<T> wait_and_pop();

    bool try_pop(T& value);

    std::shared_ptr<T> try_pop();


    void wait_and_pop(T& value, bool (*func)(const T&, int), int curIndex);

    std::shared_ptr<T> wait_and_pop(bool (*func)(const T&, int), int curIndex);

    bool try_pop(T& value, bool (*func)(const T&, int), int curIndex);

    std::shared_ptr<T> try_pop( bool (*func)(const T&, int), int curIndex);


private:
    mutable std::mutex mut;
    std::priority_queue<T, _Container, _Pr> data_queue;
    std::condition_variable data_cond;

};

实现

#include "threadsafe_priority_queue.h"
#include <iomanip>
template<typename T, class _Container, class _Pr >
threadsafe_priority_queue<T, _Container, _Pr>::threadsafe_priority_queue()
{}

template<typename T, class _Container, class _Pr >
threadsafe_priority_queue<T, _Container, _Pr>::~threadsafe_priority_queue()
{
}


template<typename T, class _Container, class _Pr >
void threadsafe_priority_queue<T, _Container, _Pr>::wait_and_pop(T& value)  // 2
{
    std::unique_lock<std::mutex> lk(mut);
    data_cond.wait(lk, [this] {return !data_queue.empty(); });
    value = std::move(data_queue.front());
    data_queue.pop();
    std::cout << "Consumer pop : " << value << std::endl;
    data_cond.notify_all();
}

template<typename T, class _Container, class _Pr >
std::shared_ptr<T> threadsafe_priority_queue<T, _Container, _Pr>::wait_and_pop()  // 3
{
    std::unique_lock<std::mutex> lk(mut);
    data_cond.wait(lk, [this] {return !data_queue.empty(); });  // 4
    std::shared_ptr<T> res(
        std::make_shared<T>(std::move(data_queue.front())));
    data_queue.pop();
    data_cond.notify_all();
    return res;
}

template<typename T, class _Container, class _Pr >
bool threadsafe_priority_queue<T, _Container, _Pr>::try_pop(T& value)
{
    std::lock_guard<std::mutex> lk(mut);
    if (data_queue.empty())
        return false;
    value = std::move(data_queue.front());
    data_queue.pop();
    data_cond.notify_all();
    return true;
}

template<typename T, class _Container, class _Pr >
std::shared_ptr<T> threadsafe_priority_queue<T, _Container, _Pr>::try_pop()
{
    std::lock_guard<std::mutex> lk(mut);
    if (data_queue.empty())
        return std::shared_ptr<T>();  // 5
    std::shared_ptr<T> res(
        std::make_shared<T>(std::move(data_queue.front())));
    data_queue.pop();
    data_cond.notify_all();
    return res;
}

template<typename T, class _Container, class _Pr >
void threadsafe_priority_queue<T, _Container, _Pr>::push(T new_value)
{
    std::unique_lock<std::mutex> lk(mut);
    data_cond.wait(lk, [this] {return data_queue.size() < MAX_SIZE; });
    std::cout.flags(std::ios::left);  //左对齐
    std::cout << "Producter push : " << new_value << std::endl;
    data_queue.push(std::move(new_value));

    data_cond.notify_all();  // 1
}

template<typename T, class _Container, class _Pr >
bool threadsafe_priority_queue<T, _Container, _Pr>::empty() const
{
    std::lock_guard<std::mutex> lk(mut);
    return data_queue.empty();
}



template<typename T, class _Container, class _Pr >
void threadsafe_priority_queue<T, _Container, _Pr>::wait_and_pop(T& value, bool (*func)(const T&, int), int curIndex )
{
    std::unique_lock<std::mutex> lk(mut);
    data_cond.wait(lk, [this, func, curIndex] {
        if (!data_queue.empty() && func(data_queue.top(), curIndex))
        {
            return true;
        }
        if (!data_queue.empty())
            std::cout << "top value: " << data_queue.top() << " ,current index : " << curIndex << std::endl;
        return false;
        });
    value = std::move(data_queue.top());
    data_queue.pop();
   //右对齐
    std::cout << std::setw(100) << setiosflags(std::ios::right)<< "Consumer pop : " << value << std::endl;
    data_cond.notify_all();
}

template<typename T, class _Container, class _Pr >
std::shared_ptr<T> threadsafe_priority_queue<T, _Container, _Pr>::wait_and_pop(bool (*func)(const T&, int), int curIndex)
{
    std::unique_lock<std::mutex> lk(mut);
    data_cond.wait(lk, [this, func, curIndex] {
        if (!data_queue.empty() && func(data_queue.front(), curIndex))
        {
            return true;
        }
        return false; 
        });  // 4
    std::shared_ptr<T> res(
        std::make_shared<T>(std::move(data_queue.front())));
    data_queue.pop();
    data_cond.notify_all();
    return res;
}

template<typename T, class _Container, class _Pr >
bool threadsafe_priority_queue<T, _Container, _Pr>::try_pop(T& value, bool (*func)(const T&, int), int curIndex)
{
    std::lock_guard<std::mutex> lk(mut);
    if (data_queue.empty() || func(data_queue.front(), curIndex))
    {
        return std::shared_ptr<T>();
    }
    std::shared_ptr<T> res(
        std::make_shared<T>(std::move(data_queue.front())));
    data_queue.pop();
    data_cond.notify_all();
    return res;
}


template<typename T, class _Container, class _Pr >
std::shared_ptr<T>  threadsafe_priority_queue<T, _Container, _Pr>::try_pop(bool (*func)(const T&, int), int curIndex)
{
    std::lock_guard<std::mutex> lk(mut);
    if (data_queue.empty() || func(data_queue.front(), curIndex))
    {
        return std::shared_ptr<T>();
    }
       
    std::shared_ptr<T> res(
        std::make_shared<T>(std::move(data_queue.front())));
    data_queue.pop();
    data_cond.notify_all();
    return res;
}

生产者

#include "threadsafe_priority_queue.h"
class Producter2
{
public:
	Producter2(threadsafe_priority_queue<int, std::vector<int>, std::greater<int>>& queue, int i);
	~Producter2();
	void start();

private:
	threadsafe_priority_queue<int, std::vector<int>, std::greater<int>>& m_pQueue;
	int index;
};

Producter2::Producter2(threadsafe_priority_queue<int, std::vector<int>, std::greater<int>>& queue, int i)
	: m_pQueue(queue), index(i)
{

}

Producter2::~Producter2()
{
}


void Producter2::start()
{
	int i = 0;
	while (i < 200)
	{
		//int data = rand();
		m_pQueue.push(i * 3 + index);
		Sleep(30);
		i++;
	}
}

消费者

 #include "threadsafe_priority_queue.h"

class Consumer2
{
public:
	Consumer2(threadsafe_priority_queue<int, std::vector<int>, std::greater<int>>& queue);
	~Consumer2();
	void start();

private:
	threadsafe_priority_queue<int, std::vector<int>, std::greater<int>>& m_pQueue;
	int m_curIndex=-1;
};

Consumer2::Consumer2(threadsafe_priority_queue<int, std::vector<int>, std::greater<int>>& queue)
	: m_pQueue(queue)
{

}

Consumer2::~Consumer2()
{
}

bool compare( const int & nextIndex,int curindex)
{
	return nextIndex == (curindex + 1);
}

void Consumer2::start()
{
	int i = 0;
	while (i < 200)
	{
		int value;
		m_pQueue.wait_and_pop(value, compare, m_curIndex);
		m_curIndex++;
		Sleep(10);
		i++;
	}
}

main函数


#include <iostream>
#include "Producter.h"
#include "Consumer.h"
# include<thread>
#include"threadsafe_queue.h"
#include"threadsafe_queue.cpp"
#include<windows.h>
#include "threadsafe_priority_queue.h"
#include "threadsafe_priority_queue.cpp"

int main()
{
	threadsafe_priority_queue<int, std::vector<int>, std::greater<int>> queue;
	Consumer2 aonsumer(queue);
	Producter2 producter(queue,0);
	Producter2 producter2(queue, 1);
	Producter2 producter3(queue, 2);
	std::thread tProducter3(&Producter2::start, &producter3);
	std::thread tProducter2(&Producter2::start, &producter2);
	std::thread tProducter1(&Producter2::start, &producter);
	std::thread tConsumer(&Consumer2::start, &aonsumer);
	
	tConsumer.join();
	tProducter3.join();
	tProducter2.join();
	tProducter1.join();
	return 0;

}

在这里插入图片描述
如何停止消费者？
采用毒丸策略
多线程生产者、消费者模式中，如何停止消费者

蜉蝣之翼❉
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++版本的生产者消费者模型
武陵人的博客
03-16 2319
C++版生产者消费者模型 字节跳动三面提到的手写代码，当时没能写出来。这几天补了一下，在此记录一下。 生产者消费者模型本身主要是利用一个缓冲区来存储数据，从而减弱生产者和消费者之间的直接关系，提高多线程下程序效率。 代码 https://github.com/Huang-Jin/ProducerConsumerDemo 参考资料 https://blog.csdn.net/lvxin153537...
c++11实现生产者消费者模型
lyl194458的博客
08-29 593
1.生产者与消费者模型 一个场所，两种角色，三种关系。（场所：线程安全的队列） 2.优点 解耦、支持忙闲不均、支持并发 3.实现 用到互斥锁，条件变量 #include <thread> #include <mutex> #include <deque> #include <vector> #include &lt...
生产消费者模式的C++实现
11-27
利用C++实现的生产消费者模式，每个生产者和消费者都在不同的线程中异步执行。
C++之生产者-消费者模式
最新发布
qq_35215756的博客
04-01 947
本文将综合运用 C++11 中的新的基础设施(主要是多线程、锁、条件变量)来阐述一个经典问题——生产者消费者模型，并给出完整的解决方案。生产者消费者问题是多线程并发中一个非常经典的问题。本文将就四种情况分析并介绍生产者和消费者问题，它们分别是：单生产者-单消费者模型，单生产者-多消费者模型，多生产者-单消费者模型，多生产者-多消费者模型。
【C++】【设计模式之】生产者-消费者模型(理论讲解及实现)
格物致知
07-12 8610
一、什么是生产者-消费者模型 1、简单理解生产者-消费者模型 假设有两个进程（或线程）A、B和一个固定大小的缓冲区，A进程生产数据放入缓冲区，B进程从缓冲区中取出数据进行计算，这就是一个简单的生产者-消费者模型。这里的A进程相当于生产者，B进程相当于消费者。 2、为什么要使用生产者-消费者模型 在多线程开发中，如果生产者生产数据的速度很快，而消费者消费数据的速度很慢，那么生产者就必须等待消费者消费完数据才能够继续生产数据，因为生产过多的数据可能会导致存储不足；同理如果消费者的速度大于生产者那么消费者就会经常
用C++实现生产者-消费者问题模型
qq_35160090的博客
06-06 1万+
用C++来实现生产者与消费者的模型，同时稍微讲解一点可能要讲解的地方。
操作系统（C++）——生产者消费者模型
weixin_51547017的博客
04-27 613
一、C++实现代码 #include<iostream> #include<queue> #include<mutex> #include<thread> #include<condition_variable> using namespace std; mutex mymutex; //定义一个互斥量，即可以理解为一把锁 //防止两个线程同时操作一个内存空间 condition_variable condition; //定义了一个条
C++实现生产者和消费者模型
热门推荐
JMW1407的博客
09-17 1万+
C++实现生产者和消费者模型 C++实现生产者和消费者模型1、实现细节1、单生产者-单消费者模型参考 C++实现生产者和消费者模型 1、实现细节 具体的实现逻辑是构建一个queue来存储生产的数据，queue不满时可以生产，不空时可以消费。 对于这个队列，采用阻塞队列的实现思路。 先实现构造函数，初始化一个unique_lock供condition_variable使用。 如何在类里面使用unique_lock等需要初始化，并且初始化会加锁的对象。这要研究下。我的理解是构造列表初始化，然后函数体里unl
[C++ 中的生产者-消费者模型]
Guojiahui的博客
10-11 597
在多线程编程中，生产者-消费者模型是一个常见的设计模式，用于协调不同线程之间的数据共享和处理。本文将介绍如何在C++中实现生产者-消费者模型，以及一些相关的概念和最佳实践。
Qt入门练习项目——生产者消费者模型.zip
08-01
Qt入门练习项目——生产者消费者模型 Qt入门练习项目源码，通过本项目从而了解Qt，进行一个简单的入门。 本文件是对应项目源码，希望多多交流。
C++实现生产与消费者模型
01-27
C++实现生产与消费者模型，利用锁实现互斥。
基于C++当消费者生产者模型
11-16
即,某时刻只允许一个实体（ 生产者或消费者） 访问缓冲区,生产者互斥消费者和其它任何生产者。 生产者/消费者必须同步 生产者不能向满缓冲区写数据，消费者也不能在空缓冲区中取数据，即生产者与消费者必须同步
基于条件变量实现的生产者消费者模型
02-18
基于Linux C++的条件变量实现的生产者消费者模型，旨在进一步帮助读者理解条件变量的使用。
消费者生产者模型 c++
09-25
//使生产者写的缓冲区可以被多个消费者使用，实现读写同步； ReleaseSemaphore(h_Semaphore[m_serial],n_Thread,NULL); } //消费者进程 void Consume(void * p) { //局部变量声明； DWORD wait_for_semaphore,m...
生产者消费者模式（c++实现）
dsjfhdwasfhgakjs的博客
10-22 1101
c++实现生产者消费者模式
如何实现一个生产者消费者模型（面试C++）
Q_Outsider的博客
08-12 802
如何实现一个生成者消费者模型（面试C++）
C++ 实现多线程的生产者(producer) - 消费者(consumer) 模型
comedate的专栏
01-27 2294
本文介绍了生产者消费者的并发编程模型，并用详细的 C++ 代码实现了一个简单的生产者消费者的实例；
生产者消费者模型（C++实现）
wangyi463295828的博客
06-06 308
#include "stdafx.h" #include <iostream> #include <memory> #include <mutex> #include <thread> #include <condition_variable> #ifdef _MSC_VER #include <windows.h> // windows #else #include <unistd.h> // linux #endi.
操作系统多生产者多消费者源代码
05-04
以下是一个使用互斥锁和条件变量实现的多生产者多消费者问题的源代码： ```c #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define BUFFER_SIZE 10 #define PRODUCER_THREADS 3 #define CONSUMER_THREADS 2 #define MAX_ITEMS 20 int buffer[BUFFER_SIZE]; int count = 0; int in = 0; int out = 0; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t full = PTHREAD_COND_INITIALIZER; pthread_cond_t empty = PTHREAD_COND_INITIALIZER; void *producer(void *arg) { int items = 0; while (items < MAX_ITEMS) { pthread_mutex_lock(&mutex); while (count == BUFFER_SIZE) { pthread_cond_wait(&empty, &mutex); } buffer[in] = items; printf("Producer %ld produced item %d\n", (long)arg, items); in = (in + 1) % BUFFER_SIZE; count++; items++; pthread_cond_signal(&full); pthread_mutex_unlock(&mutex); } return NULL; } void *consumer(void *arg) { int items = 0; while (items < MAX_ITEMS) { pthread_mutex_lock(&mutex); while (count == 0) { pthread_cond_wait(&full, &mutex); } int item = buffer[out]; printf("Consumer %ld consumed item %d\n", (long)arg, item); out = (out + 1) % BUFFER_SIZE; count--; items++; pthread_cond_signal(&empty); pthread_mutex_unlock(&mutex); } return NULL; } int main() { pthread_t producers[PRODUCER_THREADS]; pthread_t consumers[CONSUMER_THREADS]; for (long i = 0; i < PRODUCER_THREADS; i++) { pthread_create(&producers[i], NULL, producer, (void *)i); } for (long i = 0; i < CONSUMER_THREADS; i++) { pthread_create(&consumers[i], NULL, consumer, (void *)i); } for (int i = 0; i < PRODUCER_THREADS; i++) { pthread_join(producers[i], NULL); } for (int i = 0; i < CONSUMER_THREADS; i++) { pthread_join(consumers[i], NULL); } return 0; } ``` 在该代码中，我们定义了一个大小为 `BUFFER_SIZE` 的缓冲区数组 `buffer`，并使用 `count` 变量来跟踪已经在缓冲区中的项目数量。`in` 和 `out` 分别是生产者和消费者使用的索引，以便它们可以循环地访问缓冲区。 我们使用互斥锁 `mutex` 来保护共享资源的访问，以及两个条件变量 `full` 和 `empty`。生产者在缓冲区已满时等待 `empty` 条件变量，而消费者在缓冲区为空时等待 `full` 条件变量。每当生产者向缓冲区添加项目时，它会发出 `full` 条件变量的信号，以通知等待的消费者。同样，每当消费者从缓冲区移除项目时，它会发出 `empty` 条件变量的信号，以通知等待的生产者。 在 `main` 函数中，我们创建了 `PRODUCER_THREADS` 个生产者线程和 `CONSUMER_THREADS` 个消费者线程，并等待它们完成它们的工作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值