生产者消费者模式promise、future、condition_variable

Blizzard_v

已于 2022-11-11 16:05:14 修改

阅读量460

点赞数 2

分类专栏：模型部署 C++ 文章标签：开发语言 c++

于 2022-11-09 21:27:22 首次发布

本文链接：https://blog.csdn.net/Rolandxxx/article/details/127775986

版权

C++ 同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

模型部署

13 篇文章 14 订阅

订阅专栏

生产者消费者模式（多线程）

1.先写一个简单的生产者消费者模式的案例代码，其中考虑了线程安全问题：

#include <thread>
#include <queue>
#include <mutex>
#include <string>
#include <stdio.h>
#include <chrono>
#include <mutex>
using namespace std;


//共享资源访问问题
//queue这个stl对象不是thread-safe即线程安全，所以我们要对它的线程访问加锁
//线程安全的产生前提是多个线程并发访问一个共享数据。导致线程不安全
//既然是生产者消费者模式，那就得有一个任务队列
queue<string> qjobs_;
mutex lock_;

//视频捕获，生产者
void video_capture(){
	int pic_id = 0;
	while(true){
	{
	//锁可以理解为对一个共享数据的保护,线程只有拿到这个锁才可以对共享数据进行访问。一个锁只能被一个线程拥有，用完释放锁。
	    //在作用域内对mutex加锁，离开作用域析构时自动对mutex解锁
		lock_quard<mutex> l(lock_);//生产的时候加个锁
		char name[100];
		sprintf(name,"PIC-%d",pic_id++);//每次生产一个后，id就加一个
		printf("生产了一个新图片：s%\n",name);
		qjobs_.push(name);//把生产的东西加入队列
	}
	//保证频率不要太快，不要瞬间就把队列堆满了，所以加一个延时
	this_thread::sleep_for(chrono::milliseconds(1000));//1秒钟生产一个图片
	}
	
}

//模型推理，消费者
void infer_worker(){
	while(true){
		//如果不为空，就可以消费
		if(!qjobs_.empty()){
		{	
			//在作用域内对消费的时候mutex加锁，离开作用域析构时自动对mutex解锁
			lock_quard<mutex> l(lock_);//消费的时候加个锁
			//取队列最前面的一个
			auto pic = qjobs_.front();
			//删掉队列里最前面的一个，因为被取了
			qjobs_.pop();
			printf("消费掉一个图片：%s\n",pic.s_str());
		}
		//等待的时候不能锁，因为锁了后生产者就没法填充了
		//保证消费不要太快
		this_thread::sleep_for(chrono::milliseconds(1000));//1秒钟消费一个图片
		}
		
		//如果上面的if条件不满足，岂不是一直在while循环吗，会对cpu性能消耗很多
		//所以就要加一个yield，yidld意为“放弃”
		this_thread::yield();//在 this_thread 作用域下,用于暂停当前线程的调度将CPU让给其他线程
	
	}
}

int main(){

thread t0(video_capture);
thread t1(infer_worker);
t0.join();
t1.join();


return 0;
}

2.队列溢出的问题，生产太快，消费太慢。如何实现溢出限制
此时修改了下上面的代码，使得生成一个图变成500毫秒，消费一个图还是需要1秒。所以此时生成频率高于消费频率，则队列出现堆积现象，在工作的实际场景，队列通常是一张图片，一个数据会很大，如果希望系统是长期稳定运行的状态，那么就会堆积严重，程序迟早在某一刻会崩溃，因为内存被消耗殆尽。所以要做一个溢出限制，即设置一个上限，当队列达到上限时就不要继续生产了，就等就好了，等待消费者消费了后我才继续生产。主要就是通过condition_variable来实现这个通知机制，这属于被动机制，一旦有新的任务通知我即可。

#include <thread>
#include <queue>
#include <mutex>
#include <string>
#include <stdio.h>
#include <chrono>
#include <mutex>
#include <condition_variable> //带条件的变量
using namespace std;
condition_variable cv_;

//共享资源访问问题
//queue这个stl对象不是thread-safe即线程安全，所以我们要对它的线程访问加锁
//线程安全的产生前提是多个线程并发访问一个共享数据。导致线程不安全
//既然是生产者消费者模式，那就得有一个任务队列
queue<string> qjobs_;
mutex lock_;
const int limit_=5


//视频捕获，生产者
void video_capture(){
	int pic_id = 0;
	while(true){
	{
	//锁可以理解为对一个共享数据的保护,线程只有拿到这个锁才可以对共享数据进行访问。一个锁只能被一个线程拥有，用完释放锁。
	    //在作用域内对mutex加锁，离开作用域析构时自动对mutex解锁
		unique_lock<mutex> l(lock_);//生产的时候加个锁, 这个锁和上面代码的锁不同，这是唯一锁。
		char name[100];
		sprintf(name,"PIC-%d",pic_id++);//每次生产一个后，id就加一个
		printf("生产了一个新图片：s%\n",name);
		
		
		//如果队列满了，我不生产，我去等待队列有空间再生产
		//如果队列小于limit了，就要通知生产者继续生产，通知时就存在一个问题，即如何通知到wait，让它及时可以退出
		//通知是交给消费者来通知
		//wait函数传入两个参数，一个是锁(唯一锁)，一个是predicate。
		//wait的流程是一旦进入wait，则解锁
		//            一旦退出wait，则加锁
		//[&]()为c++的lambda表达式
		cv_.wait(l,[&](){
			//下面是wait函数的条件
			//return false 表示继续等待
			//return true 表示不等待，跳出wait
			return qjobs_.size() < limit_;
		}); //里面的是wait函数的参数
		
		qjobs_.push(name);//把生产的东西加入队列

	}
	//保证频率不要太快，不要瞬间就把队列堆满了，所以加一个延时
	this_thread::sleep_for(chrono::milliseconds(500));//500毫秒生产一个图片
	}
	
}

//模型推理，消费者
void infer_worker(){
	while(true){
		//如果不为空，就可以消费
		if(!qjobs_.empty()){
		{	
			//在作用域内对消费的时候mutex加锁，离开作用域析构时自动对mutex解锁
			lock_quard<mutex> l(lock_);//消费的时候加个锁
			//取队列最前面的一个
			auto pic = qjobs_.front();
			//删掉队列里最前面的一个，因为被取了
			qjobs_.pop();
			
			//消费掉一个，就可以通知wait，去跳出等待
			cv_.notify_one();
	
			printf("消费掉一个图片：%s\n",pic.s_str());
		}
		//等待的时候不能锁，因为锁了后生产者就没法填充了
		//保证消费不要太快
		this_thread::sleep_for(chrono::milliseconds(1000));//1秒钟消费一个图片
		}
		
		//如果上面的if条件不满足，岂不是一直在while循环吗，会对cpu性能消耗很多
		//所以就要加一个yield，yidld意为“放弃”
		this_thread::yield();//在 this_thread 作用域下,用于暂停当前线程的调度将CPU让给其他线程
	
	}
}

int main(){

thread t0(video_capture);
thread t1(infer_worker);
t0.join();
t1.join();


return 0;
}

3.生产者如何拿到消费反馈
消费者对产品做了一个处理后，就会有一个新的结果，即下面代码中的new_pic，new_pic想要送回给生产者应该怎么办？为什么要把生产者生产的东西通过消费者后再送回去呢？送回去的意义是什么呢？因为我们是希望拿到拿到一张图像（生产者给的）后生成推理结果（消费者处理后的），跟推理之前的图像一起进行画框，然后走下面流程。
这个时候或许会好奇，为什么要绕一圈子先通过一个线程读取图片，再通过另一个线程去消费，然后再把结果送回来然后再去画框呢，为什么不直接把模型放到一个线程里读取了图片后拿到结果然后直接就画框。因为这是一个很典型的场景，通常来讲我们有很多个模型，不是一个模型，就意味着我们的infer_woker不是一个，而是有很多个，就相当于一个生产者对应了有很多个消费者，此时就会有很多队列，一个消费者对应一个队列。如果你全部放到video_capture里面一个一个去做的话，就是一个串行的模式了（同步），性能很差。而我们希望的是模型推理是同时并发进行的（异步），在生产者线程中执行多次push，即都把东西push进去各自模型的队列中，因为push并不耗时，然后最后能一次进行所有模型推理结果的回收，然后进行画框处理，这样效率会高很多。同步调用（同步就意味着一个一个挨着执行，执行完了下一个再执行，所以同步是指都放在一个线程里）还有一个很大的缺陷就是对这个线程的承载是非常重的。当调用你这个线程执行你算法的操作时，如果太重了就会使得性能比较差，因为你的线程上下文是需要初始化的，你的线程里有很多内容是需要分配资源的。所以如果我的调用的逻辑跟你的推理的逻辑不在一个线程里，就会使得调用非常轻便，性能非常好，接口也更加简单便利。
生产者如何拿到消费反馈这个实现主要由promise、future实现，在拿到反馈的结果之前也有一个等待的机制在里面。

#include <thread>
#include <queue>
#include <mutex>
#include <string>
#include <stdio.h>
#include <chrono>
#include <mutex>
#include <condition_variable> //带条件的变量
#include <memory>
#include <future>
using namespace std;
condition_variable cv_;

//共享资源访问问题
//queue这个stl对象不是thread-safe即线程安全，所以我们要对它的线程访问加锁
//线程安全的产生前提是多个线程并发访问一个共享数据。导致线程不安全
//既然是生产者消费者模式，那就得有一个任务队列
queue<job> qjobs_;
struct Job{
	//用shared_ptr使得结构传递时不会被复制
	//如果是在深度学习里面这个string类型就应该换成bbox，即返回值的类型
	shared_ptr<promise<string>> pro;
	string input;

};

mutex lock_;
const int limit_=5


//视频捕获，生产者
void video_capture(){
	int pic_id = 0;
	while(true){
	Job job;
	{
	//锁可以理解为对一个共享数据的保护,线程只有拿到这个锁才可以对共享数据进行访问。一个锁只能被一个线程拥有，用完释放锁。
	    //在作用域内对mutex加锁，离开作用域析构时自动对mutex解锁
		unique_lock<mutex> l(lock_);//生产的时候加个锁, 这个锁和上面代码的锁不同，这是唯一锁。
		char name[100];
		sprintf(name,"PIC-%d",pic_id++);//每次生产一个后，id就加一个
		printf("生产了一个新图片：s%\n",name);
		
		
		//如果队列满了，我不生产，我去等待队列有空间再生产
		//如果队列小于limit了，就要通知生产者继续生产，通知时就存在一个问题，即如何通知到wait，让它及时可以退出
		//通知是交给消费者来通知
		//wait函数传入两个参数，一个是锁(唯一锁)，一个是predicate。
		//wait的流程是一旦进入wait，则解锁
		//            一旦退出wait，则加锁
		cv_.wait(l,[&](){
			//下面是wait函数的条件
			//return false 表示继续等待
			//return true 表示不等待，跳出wait
			return qjobs_.size() < limit_;
		});
		//生产者通过promise告诉他你一定得在未来给我返回一个结果
		job.pro.reset(new promise<string>());
		job.input =name;
		qjobs_.push(job);//把生产的东西加入队列
		}
	//拿结果这个过程要放到锁的作用域外面，不然就会又在等待又在锁，造成死锁，程序就会出问题了
	//等待这个job处理完毕，拿结果
	//.get过后实现等待，直到promise->set_value被执行了，这里get拿到的返回值就是result
	auto result = job.pro->get_future().get();
	printf("JOB %s -> %s\n",job.input.c_str(),result.c_str());
	//保证频率不要太快，不要瞬间就把队列堆满了，所以加一个延时
	this_thread::sleep_for(chrono::milliseconds(500));//500毫秒生产一个图片
	}
	
}

//模型推理，消费者
void infer_worker(){
	while(true){
		//如果不为空，就可以消费
		if(!qjobs_.empty()){
		{	
			//在作用域内对消费的时候mutex加锁，离开作用域析构时自动对mutex解锁
			lock_quard<mutex> l(lock_);//消费的时候加个锁
			//取队列最前面的一个
			auto pjob = qjobs_.front();
			//删掉队列里最前面的一个，因为被取了
			qjobs_.pop();
			
			//消费掉一个，就可以通知wait，去跳出等待
			cv_.notify_one();
	
			printf("消费掉一个图片：%s\n",pjob.input.s_str());
			
			auto result= pjob.input + "----infer";
			//new_pic想要送回给生产者应该怎么办，通过以下代码执行
			pjob.pro->set_value(result);
		}
		//等待的时候不能锁，因为锁了后生产者就没法填充了
		//保证消费不要太快
		this_thread::sleep_for(chrono::milliseconds(1000));//1秒钟消费一个图片
		}
		
		//如果上面的if条件不满足，岂不是一直在while循环吗，会对cpu性能消耗很多
		//所以就要加一个yield，yidld意为“放弃”
		this_thread::yield();//在 this_thread 作用域下,用于暂停当前线程的调度将CPU让给其他线程
	
	}
}

int main(){

thread t0(video_capture);
thread t1(infer_worker);
t0.join();
t1.join();


return 0;
}

refer:
C++ 这个语句中[&] () 是什么意思

Blizzard_v

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
生产者消费者模式promise、future、condition_variable

同步调用（同步就意味着一个一个挨着执行，执行完了下一个再执行，所以同步是指都放在一个线程里）还有一个很大的缺陷就是对这个线程的承载是非常重的。当调用你这个线程执行你算法的操作时，如果太重了就会使得性能比较差，因为你的线程上下文是需要初始化的，你的线程里有很多内容是需要分配资源的。所以如果我的调用的逻辑跟你的推理的逻辑不在一个线程里，就会使得调用非常轻便，性能非常好，接口也更加简单便利。
复制链接

扫一扫