C++11多线程笔记四（部署中的生产者消费者模式）

最新推荐文章于 2023-10-05 16:52:51 发布
最新推荐文章于 2023-10-05 16:52:51 发布
阅读量316 收藏 1
点赞数
文章标签： c++ 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nanjono/article/details/131649640
版权
本文介绍了C++中实现生产者消费者模式的方法，包括基本的队列操作、互斥锁和条件变量的使用，以及如何处理队列溢出和生产者获取消费者反馈的情况。通过示例代码展示了如何利用线程安全的数据结构和并发工具来协调生产者和消费者的执行，确保系统稳定和高效。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

部署中多线程常用组件：thread, join, joinable, detach, mutex, promise, future, condition_variable, 生产者消费者模式

一、模拟部署中的生产者消费者

1. 最简单实现

#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <string>
#include <stdio.h>

using namespace std;
queue<string> qjobs_;

void video_capture() {
	int pic_id = 0;
	while (true) {
		char name[100];
		sprintf_s(name, "PIC-%d", pic_id++);
		printf("生成了一个新图片:%s\n", name);
		qjobs_.push(name);
		//读图1s
		this_thread::sleep_for(chrono::milliseconds(1000));
	}
}

void infer_worker() {
	while (true) {
		if (!qjobs_.empty()) {
			auto pic = qjobs_.front();
			qjobs_.pop();
			printf("消耗掉一个图片：%s\n", pic.c_str());
			//推理1s
			this_thread::sleep_for(chrono::milliseconds(1000));
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}
int main() {
	thread t0(video_capture);
	thread t1(infer_worker);
	t0.join();
	t1.join();
	return 0;
}

2. queue，stl对象不是thread-safe，需要加锁

#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <string>
#include <stdio.h>

using namespace std;
queue<string> qjobs_;
mutex lock_;

void video_capture() {
	int pic_id = 0;
	while (true) {
		{
			lock_guard<mutex> l(lock_);    //作用域在大括号{}，生产过程枷锁，超过作用域析构自动解锁
			char name[100];
			sprintf_s(name, "PIC-%d", pic_id++);
			printf("生成了一个新图片:%s\n", name);
			qjobs_.push(name);
		}//自动解锁
		//读图1s
		this_thread::sleep_for(chrono::milliseconds(1000));
	}
}

void infer_worker() {
	while (true) {
		if (!qjobs_.empty()) {
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				auto pic = qjobs_.front();
				qjobs_.pop();
				printf("消耗掉一个图片：%s\n", pic.c_str());
			}
			//推理1s
			this_thread::sleep_for(chrono::milliseconds(1000));
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}
int main() {
	thread t0(video_capture);
	thread t1(infer_worker);
	t0.join();
	t1.join();
	return 0;
}

二、队列溢出问题：生产太快，消费太慢

1. 生产速度大小消费速度造成队列堆积现象

#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <string>
#include <stdio.h>

using namespace std;
queue<string> qjobs_;
mutex lock_;

void video_capture() {
	int pic_id = 0;
	while (true) {
		{
			lock_guard<mutex> l(lock_);    //作用域在大括号{}，生产过程枷锁，超过作用域析构自动解锁
			char name[100];
			sprintf_s(name, "PIC-%d", pic_id++);
			printf("生成了一个新图片:%s, qjobs_size = %d\n", name, qjobs_.size());
			qjobs_.push(name);
		}//自动解锁
		//读图1s
		this_thread::sleep_for(chrono::milliseconds(500));
	}
}

void infer_worker() {
	while (true) {
		if (!qjobs_.empty()) {
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				auto pic = qjobs_.front();
				qjobs_.pop();
				printf("消耗掉一个图片：%s\n", pic.c_str());
			}
			//推理1s
			this_thread::sleep_for(chrono::milliseconds(1000));
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}
int main() {
	thread t0(video_capture);
	thread t1(infer_worker);
	t0.join();
	t1.join();
	return 0;
}

打印结果：
在这里插入图片描述
例子使用的是string，但实际推理中queue中存的是图片，如果图片大小是1280 * 720 * 3，容易显存消耗殆尽，程序崩溃

2. 解决方法：设置生产上限

  • 达到生产上限停止生产，等待消费者推理完成，队列有空间再生产
  • 使用condition_variable，传的参数是unique_lock
  • 流程：判断队列的数量是否超过了limit，如果超过，则一直wait()，且此时解锁，直到消费掉一个，使用notice_one()通知生产者，跳出wait()，同时生产者加锁
#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <string>
#include <stdio.h>

using namespace std;
queue<string> qjobs_;
mutex lock_;
condition_variable cv_;
const int limit_ = 5;

void video_capture() {
	int pic_id = 0;
	while (true) {
		{
			unique_lock<mutex> l(lock_);    //作用域在大括号{}，生产过程枷锁，超过作用域析构自动解锁
			char name[100];
			sprintf_s(name, "PIC-%d", pic_id++);
			printf("生成了一个新图片:%s, qjobs_size = %d\n", name, qjobs_.size());
			//if (qjobs_.size() > limit)
			//	wait();
			cv_.wait(l, [&]() {
				//return false:继续等待
				//return true:等待结束，跳出wait
				//进入wait，解锁
				//跳出wait，加锁
				return qjobs_.size() < limit_;
			});
			qjobs_.push(name);
			// 如果队列满了不生产，等待队列有空间再生产
			// 通知的问题，如果即使通知到wait，让他随时可以退出

		}//自动解锁
		//读图1s
		this_thread::sleep_for(chrono::milliseconds(500));
	}
}

void infer_worker() {
	while (true) {
		if (!qjobs_.empty()) {
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				auto pic = qjobs_.front();
				qjobs_.pop();
				//消费掉一个，通知wait()，跳出等待
				cv_.notify_one();
				printf("消耗掉一个图片：%s\n", pic.c_str());
			}
			//推理1s
			this_thread::sleep_for(chrono::milliseconds(1000));
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}
int main() {
	thread t0(video_capture);
	thread t1(infer_worker);
	t0.join();
	t1.join();
	return 0;
}

打印结果：队列数量不超过limit = 5
在这里插入图片描述

三、生产者拿到消费者的反馈

推理过程中，有很多种模型，比如目标检测、车道线检测、深度估计等，即有很多个消费者，多个消费者异步推理，消费者推理完图片得到的结果要反馈给生产者，进行后处理和画框等

同步模式： detection -> infer， face -> infer， feature -> infer

异步模式： detaction -> push， face -> push， feature -> push 一次进行三个结果的回收，然后处理

#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <future>
#include <memory>
#include <string>
#include <stdio.h>


using namespace std;

struct Job {
	shared_ptr<promise<string>> pro;
	string input;
};
queue<Job> qjobs_;
mutex lock_;
condition_variable cv_;
const int limit_ = 5;

void video_capture() {
	int pic_id = 0;
	while (true) {
		Job job;
		{
			unique_lock<mutex> l(lock_);    //作用域在大括号{}，生产过程枷锁，超过作用域析构自动解锁
			char name[100];
			sprintf_s(name, "PIC-%d", pic_id++);
			printf("生成了一个新图片:%s, qjobs_size = %d\n", name, qjobs_.size());
			//if (qjobs_.size() > limit)
			//	wait();
			cv_.wait(l, [&]() {
				//return false:继续等待
				//return true:等待结束，跳出wait
				//进入wait，解锁
				//跳出wait，加锁
				return qjobs_.size() < limit_;
			});
			// 如果队列满了不生产，等待队列有空间再生产
			// 通知的问题，如果即使通知到wait，让他随时可以退出
			job.pro.reset(new promise<string>());
			job.input = name;
			qjobs_.push(job);

		}//自动解锁
		//等待这个job处理完毕，拿到结果
		//.get过后，实现等待，知道promise->set_value执行了，返回值就是result
		auto result = job.pro->get_future().get();
		printf("JOB %s -> %s\n", job.input.c_str(), result.c_str());
		//拿到推理结果，几个推理结果一起画框
		//读图1s
		this_thread::sleep_for(chrono::milliseconds(500));
	}
}

void infer_worker() {
	while (true) {
		if (!qjobs_.empty()) {
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				auto pjob = qjobs_.front();
				qjobs_.pop();
				//消费掉一个，通知wait()，跳出等待
				cv_.notify_one();
				printf("消耗掉一个图片：%s\n", pjob.input.c_str());

				auto result = pjob.input + "-----------infer";
				//new_pic返回生产者
				pjob.pro->set_value(result);
			}
			//推理1s
			this_thread::sleep_for(chrono::milliseconds(1000));
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}
int main() {
	thread t0(video_capture);
	thread t1(infer_worker);
	t0.join();
	t1.join();
	return 0;
}

打印结果：
在这里插入图片描述

不需要condition_variable 了

#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <future>
#include <memory>
#include <string>
#include <stdio.h>

using namespace std;
struct Job {
	shared_ptr<promise<string>> pro;
	string input;
};
queue<Job> qjobs_;
mutex lock_;
const int limit_ = 5;

void video_capture() {
	int pic_id = 0;
	while (true) {
		Job job;
		{
			lock_guard<mutex> l(lock_);    //作用域在大括号{}，生产过程枷锁，超过作用域析构自动解锁
			char name[100];
			sprintf_s(name, "PIC-%d", pic_id++);
			printf("生成了一个新图片:%s, qjobs_size = %d\n", name, qjobs_.size());

			job.pro.reset(new promise<string>());
			job.input = name;
			qjobs_.push(job);

		}//自动解锁
		//等待这个job处理完毕，拿到结果
		//.get过后，实现等待，知道promise->set_value执行了，返回值就是result
		auto result = job.pro->get_future().get();
		printf("JOB %s -> %s\n", job.input.c_str(), result.c_str());
		//拿到推理结果，几个推理结果一起画框
		//读图1s
		this_thread::sleep_for(chrono::milliseconds(500));
	}
}

void infer_worker() {
	while (true) {
		if (!qjobs_.empty()) {
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				auto pjob = qjobs_.front();
				qjobs_.pop();
				printf("消耗掉一个图片：%s\n", pjob.input.c_str());

				auto result = pjob.input + "-----------infer";
				//new_pic返回生产者
				pjob.pro->set_value(result);
			}
			//推理1s
			this_thread::sleep_for(chrono::milliseconds(1000));
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}
int main() {
	thread t0(video_capture);
	thread t1(infer_worker);
	t0.join();
	t1.join();
	return 0;
}

多个推理模型的模拟（一个生产者多个消费者）：

#include <iostream>
#include <thread>
#include <chrono>
#include <queue>
#include <mutex>
#include <future>
#include <memory>
#include <string>
#include <stdio.h>

using namespace std;
struct Job {
	shared_ptr<promise<string>> pro;
	string input;
};
queue<Job> qjobs1_;
queue<Job> qjobs2_;
queue<Job> qjobs3_;
mutex lock_;

// 图像处理函数示例：目标检测
string detect(const string& image) {
	// 模拟目标检测的处理时间
	this_thread::sleep_for(chrono::milliseconds(1000));

	cout << "目标检测完成" << endl;
	return "目标检测结果";
}

// 图像处理函数示例：车道线检测
string laneDetection(const string& image) {
	// 模拟车道线检测的处理时间
	this_thread::sleep_for(chrono::milliseconds(1500));
	cout << "车道线检测完成" << endl;
	return "车道线检测结果";
}

// 图像处理函数示例：深度估计
string depthEstimation(const string& image) {
	// 模拟深度估计的处理时间
	this_thread::sleep_for(chrono::milliseconds(2000));
	cout << "深度估计完成" << endl;
	return "深度估计结果";
}

void video_capture() {
	int pic_id = 0;
	while (true) {
		Job job1;
		Job job2;
		Job job3;
		{
			lock_guard<mutex> l(lock_);    //作用域在大括号{}，生产过程枷锁，超过作用域析构自动解锁
			char name[100];
			sprintf_s(name, "PIC-%d", pic_id++);
			printf("生成了一个新图片:%s, qjobs_size = %d\n", name, qjobs1_.size());

			job1.pro.reset(new promise<string>());
			job1.input = name;
			job2.pro.reset(new promise<string>());
			job2.input = name;
			job3.pro.reset(new promise<string>());
			job3.input = name;
			qjobs1_.push(job1);
			qjobs2_.push(job2);
			qjobs3_.push(job3);
		}//自动解锁
		//等待这个job处理完毕，拿到结果
		//.get过后，实现等待，知道promise->set_value执行了，返回值就是result
		auto result1 = job1.pro->get_future().get();
		auto result2 = job2.pro->get_future().get();
		auto result3 = job3.pro->get_future().get();
		printf("JOB %s -> %s\n", job1.input.c_str(), result1.c_str());
		printf("JOB %s -> %s\n", job2.input.c_str(), result2.c_str());
		printf("JOB %s -> %s\n", job3.input.c_str(), result3.c_str());
		//拿到推理结果，几个推理结果一起画框
		//读图1s
		this_thread::sleep_for(chrono::milliseconds(2000));
	}
}

void infer_worker1() {
	while (true) {
		if (!qjobs1_.empty()) {
			Job pjob;
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				pjob = qjobs1_.front();
				qjobs1_.pop();
				printf("消耗掉一个图片：%s\n", pjob.input.c_str());
			}
			//目标检测
			string detectionResult = detect(pjob.input);
			auto result = pjob.input + "----------" + detectionResult;
			//new_pic返回生产者
			pjob.pro->set_value(result);
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}

void infer_worker2() {
	while (true) {
		if (!qjobs2_.empty()) {
			Job pjob;
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				pjob = qjobs2_.front();
				qjobs2_.pop();
				printf("消耗掉一个图片：%s\n", pjob.input.c_str());
			}
			//车道线检测
			string laneDetectionResult = laneDetection(pjob.input);
			auto result = pjob.input + "----------" + laneDetectionResult;
			//new_pic返回生产者
			pjob.pro->set_value(result);
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}

void infer_worker3() {
	while (true) {
		if (!qjobs3_.empty()) {
			Job pjob;
			{
				//lock_guard作用域在大括号{}，消费过程枷锁，数据从队列一瞬间加锁，超过作用域析构自动解锁
				//推理等待过程不加锁，不然无法填充
				lock_guard<mutex> l(lock_);
				pjob = qjobs3_.front();
				qjobs3_.pop();
				printf("消耗掉一个图片：%s\n", pjob.input.c_str());
			}
			//深度估计
			string depthEstimationResult = depthEstimation(pjob.input);
			auto result = pjob.input + "----------" + depthEstimationResult;
			//new_pic返回生产者
			pjob.pro->set_value(result);
		}
		this_thread::yield();    //交出cpu控制权，进入空闲状态，继续等待下一个时间片
	}
}

int main() {
	thread t0(video_capture);
	thread t1(infer_worker1);
	thread t2(infer_worker2);
	thread t3(infer_worker3);
	t0.join();
	t1.join();
	t2.join();
	t3.join();
	return 0;
}
nanjono
关注
多线程编程学习笔记 by blast
最新发布
11-16
条件变量（condition_variable）是C++11提供的另一种同步机制，常用于生产者-消费者模型。它允许线程在某个条件未满足时挂起，并在条件满足时由另一线程唤醒。条件变量通常与互斥量配合使用，以确保线程间的正确同步...
生产者消费者的c++代码实现
11-29
计算机操作系统经典的生产者消费者问题c++高级语言的实现。编程入门必备。
UNIX(多线程)：20---生产者消费者实例
网易搬砖头
01-19 319
本文将综合运用 C++11 中的新的基础设施(主要是多线程、锁、条件变量)来阐述一个经典问题——生产者消费者模型，并给出完整的解决方案。生产者消费者问题是多线程并发中一个非常经典的问题，...
C++11 生产者消费者
weixin_33787529的博客
04-08 103
下面是一个生产者消费者问题，来介绍condition_variable的用法。当线程间的共享数据发生变化的时候，可以通过condition_variable来通知其他的线程。消费者wait 直到生产者通知其状态发生改变，Condition_variable是使用方法如下： ·当持有锁之后，线程调用wait ·wait解开持有的互斥锁(mutex)，阻塞本线程，并将自己加入到唤醒队列中 ·当收...
C++11之生产者消费者
NB_vol_1的专栏
02-25 1799
#include #include #include #include using namespace std; // 定义两个条件变量 // 队列未满 std::condition_variable QueueNotFull; // 队列不空 std::condition_variable QueueNotEmpty; // 队列锁 std::mutex QueueM
C++11实现生产者消费者
yun6853992的博客
06-20 561
生产者消费者问题源码实现，使用c++11： 主要使用c++的锁和条件变量实现 /************************************ 生产者消费者，多线程实现问题 有一个存储的队列 生产者生产 消费者取消费 1：注意：结构体作为参数，&是引用传递 *是地址传递 2：互斥锁的实现和条件变量 ************************************/ #include <thread> #include <mutex> #includ
C++11 生产者消费者模型
qq_43533792的博客
08-29 714
C++11实现生产者消费者模型
C++笔记之不同buffer数量下的生产者-消费者机制
小勇博客
10-05 938
总的来说，单个缓冲区和多个缓冲区的主要区别在于资源的共享方式和并发性能。单个缓冲区通常更简单，但并发性能可能较低，因为所有的生产者和消费者都要竞争同一个缓冲区。多个缓冲区可以提高并发性能，但需要更复杂的管理和同步机制来维护多个缓冲区的状态。在 C++ 中可以使用 std::condition_variable 来实现生产者和消费者模式：生产者在缓冲区未满时不断添加数据，并唤醒消费者进行数据读取；下面将比较这三种情况：一个缓冲区、两个缓冲区和三个缓冲区下的生产者-消费者机制的实现。
Linux系统编程39：多线程之基于阻塞队列生产者与消费者模型
快乐江湖的博客
04-30 593
文章目录（1）生产者与消费者模型概述（2）生产者与消费者模型优点（3）基于阻塞队列（blockingqueue）的生产者消费者模型（单消费者单生产者）（4）基于阻塞队列（blockingqueue）的生产者消费者模型（多消费者多生产者）（4）基于阻塞队列（blockingqueue）的生产者消费者模型（实际模型） （1）生产者与消费者模型概述 在现实生活中，当我们缺少某些生活用品时，就回到超市去购买。当你到超市时，你的身份就是消费者，那么这些商品又是哪里来的呢，自然是供应商，那么它们就是生产者，而超市在生产
python多线程及condition版生产者-消费者模型
Heibaiii的博客
04-11 3518
写在前面 多线程的概念 Python中的多线程 生产者-消费者模型 Condition版生产者-消费者模型代码示例 线程优先级队列（ Queue） GIL全局解释锁（Global Interceptor Lock） 扩展 写在前面 python（基于cpython解释器）的多线程其实是假多线程，是单个CPU在多个线程间迅速切换营造出来的‘错觉’,所以Python的多线程...
【面试笔记】c++高频多线程面试题代码
qq_40358998的博客
09-01 1405
本文内容： 记录面试常见的c++中多线程问题及其代码 1.单例模式 懒汉模式 在使用该类时才初始化 class singleton { private: static singleton* p; singleton() {} public: static singleton* instance(); }; singleton* singleton::instance() { if (p == nullptr) { p = new singleton();
适用于C ++ 11的快速多生产者，多消费者，无锁定并发队列-C/C++开发
05-26
moodycamel :: ConcurrentQueue用于C ++的工业强度无锁队列。 注意：如果您需要的只是一个单一生产者，单一消费者队列，那么我也可以选择其中之一。 特色快如闪电般的快速pe moodycamel :: ConcurrentQueue C ++的工业级无锁队列。 注意：如果您需要的只是一个单一生产者，单一消费者队列，那么我也可以选择其中之一。 具有敲击您的袜子的出色性能。 单头实现。 只需将其放入您的项目中即可。 完全线程安全的无锁队列。 从任何数量的线程中并发使用。 C ++ 11实现-尽可能移动（而不是复制）元素。 模板化，无需专门处理机智
c++11实现生产者消费者模型
lyl194458的博客
08-29 636
1.生产者与消费者模型 一个场所，两种角色，三种关系。（场所：线程安全的队列） 2.优点 解耦、支持忙闲不均、支持并发 3.实现 用到互斥锁，条件变量 #include <thread> #include <mutex> #include <deque> #include <vector> #include &lt...
C++11学习生产者消费者
webgpu
02-24 364
就是有一个东西 有人生产有人用#include&lt;iostream&gt;#include&lt;thread&gt;#include&lt;mutex&gt;#include&lt;condition_variable&gt;#include&lt;list&gt;#include&lt;memory&gt;using namespace std;#define MaxSize   5std...
C++11多线程练习 ——生产者与消费者
welcom to Rita's world
02-24 419
C++11多线程联系 ——生产者与消费者生产者与消费者问题 生产者与消费者问题 生产者与消费者问题:所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。 struct Repository { struct Repository(int product_num, int con_num, int pro_num) :products_num(product_num) , consumer_
C++11并发学习之五：生产者与消费者
草上爬的博客
11-15 3649
本文将实现单生产者-多消费者模型、多生产者-单消费者模型和多生产者-多消费者模型。前两种实际上是简化版的多生产者-多消费者，因此只需要实现第三种。中实际上用条件变量实现了一个简单的单生产者-单消费者模型，也就是一个生产者和一个消费者。
c++11 多线程实现生产者消费者模型
bixinwei22的专栏
12-29 408
#include <stdio.h> #include <iostream> #include <thread> #include <mutex> #include <condition_variable> #include <queue> using namespace std;const int length = 5; int buffer[length]; int read_index; i
【C++11】【多线程与并发】C++11 多线程下生产者消费者模型详解
qq_43331089的博客
05-05 722
【C++11】【多线程与并发】C++11 多线程下生产者消费者模型详解 生产者消费者问题是多线程并发中一个非常经典的问题，相信学过操作系统课程的同学都清楚这个问题的根源。本文将就四种情况分析并介绍生产者和消费者问题，它们分别是：单生产者-单消费者模型，单生产者-多消费者模型，多生产者-单消费者模型，多生产者-多消费者模型，我会给出四种情况下的 C++11 并发解决方案，如果文中出现了错误或者你对代码有异议，欢迎交流 😉。 单生产者-单消费者模型 顾名思义，单生产者-单消费者模型中只有一个生产者和一个消费者，
C++11多线程消费者生产者问题
GuoZzzCHEN的博客
01-06 573
C++11 在类中封装消费者生产者问题，用多线程实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值