Linux系统编程（20）——生产者-消费者模型基础示例（栈、队列实现、实现线程池）

最新推荐文章于 2021-05-07 05:37:44 发布
最新推荐文章于 2021-05-07 05:37:44 发布
阅读量357 收藏
点赞数
分类专栏： Linux 其他 文章标签： 生产者消费者模型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42659468/article/details/90796223
版权

生产者-消费者模型

多线程场景的的典型应用，应用场景非常广泛！手撕！！！

  • 消费者和消费者之间，是一个互斥关系。
  • 生产者和生产者之间，是一个互斥关系。
  • 生产者和消费者之间，是一个互斥同步关系。

注：同步互斥不一定非要用互斥锁和条件变量，还可以用信号量。

代码示例1：（栈实现，互斥锁/条件变量实现互斥同步）

#include <stdio.h>
#include<pthread.h> //头文件
#include <unistd.h>  //sleep头文件
#include <vector>

//定义一个互斥锁
pthread_mutex_t mutex;


//实现一个生产者消费者模型
//首先要有一个交易场所
std::vector<int> data;

//两个角色：生产者/消费者——两个线程
void* Product(void* arg) {
	(void*)arg;
	int count = 0;
	//负责把数据送到的交易场所中
	while (1)	{
		pthread_mutex_lock(&lock);
		data.push_back(++count);
		pthread_mutex_unlock(&lock);
		usleep(789789);
	}
	return NULL;
}

void* Consume(void* arg) {
	(void*)arg;
	//负责把交易场所中的数据获取出来
	while (1) {
		pthread_mutex_lock(&lock);
		//每次取最后一个元素
		//注意判空
		if (!data.empty()) {
			int result = data.back();
			data.pop_back();
			printf("result = %d\n", result);
		}
		pthread_mutex_unlock(&lock);
		usleep(123123);
	}
	return NULL;
}


int main() {

	pthread_mutex_init(&lock, NULL);//互斥锁初始化函数

	pthread_t tid1, tid2;
	pthread_create(&tid1, NULL, Product, NULL); //创建新线程
	pthread_create(&tid2, NULL, Consume, NULL);

	pthread_join(tid1,NULL); //线程等待
	pthread_join(tid2, NULL);


	pthread_mutex_destory(&lock);//互斥锁释放函数
	system("pause");
	return 0;
}

//不加互斥锁：
//但是使用过多线程，就有可能有段错误。
//因为C++STL中所提供的容器和算法都是线程不安全[重要]

//加上互斥锁：保证线程安全。

结果：

实现了不断加1，打印。但是使用过多线程，就有可能有段错误。因为 C++STL 中所提供的容器和算法都是线程不安全[重要]。加上互斥锁就好了。

刚刚互斥锁这是实现了：消费者和生产者的互斥关系，效率不是很高。消费者做了很多无用功，因为他的速度更快。这时候可以同步进一步改进。如果vector 没数据，消费者就等，有数据才真正进行消费。

下面是加上条件变量——即实现同步。谁快谁等。

完整代码：

#include <stdio.h>
#include<pthread.h> //头文件
#include <unistd.h>  //sleep头文件
#include <vector>

//定义一个互斥锁
pthread_mutex_t mutex;
//定义同步——条件变量
pthread_cond_t cond;


//实现一个生产者消费者模型
//首先要有一个交易场所
std::vector<int> data;

//两个角色：生产者/消费者——两个线程
void* Product(void* arg) {
	(void*)arg;
	int count = 0;
	//负责把数据送到的交易场所中
	while (1)	{
		pthread_mutex_lock(&lock);
		data.push_back(++count);
		pthread_mutex_unlock(&lock);
		pthread_cond_signal(&lock); //去通知
		usleep(789789);
	}
	return NULL;
}

void* Consume(void* arg) {
	(void*)arg;
	//负责把交易场所中的数据获取出来
	while (1) {
		pthread_mutex_lock(&lock);
		//每次取最后一个元素
		//注意判空,因为快，所以等
//这里用while 的原因是：pthread_cond_wait()不一定返回的是其他线程的signal
//有可能被信号打断
		while(data.empty()) {
			//1.释放锁
			//2.等待条件就绪（其他线程调用 pthread_cond_signal）   //1，2原子的
			//3.条件就绪了，重新获取锁
			//加上wait的意义：没有数据，消费者数据不会空转，节省了资源。
			pthread_cond_wait(&cond, &lock);
		}

		int result = data.back();
		data.pop_back();
		printf("result = %d\n", result);
		pthread_mutex_unlock(&lock);
		usleep(123123);
	}
	return NULL;
}


int main() {

	pthread_mutex_init(&lock, NULL);//互斥锁初始化函数
	pthread_cond_init(&cond, NULL);//条件变量初始化函数

	pthread_t tid1, tid2;
	pthread_create(&tid1, NULL, Product, NULL); //创建新线程
	pthread_create(&tid2, NULL, Consume, NULL);

	pthread_join(tid1,NULL);  //线程等待
	pthread_join(tid2, NULL);

	
	pthread_cond_destory(&cond);//条件变量释放函数
	pthread_mutex_destory(&lock);	
	return 0;
}

//不加互斥锁：
//但是使用过多线程，就有可能有段错误。
//因为C++STL中所提供的容器和算法都是线程不安全[重要]

//加上互斥锁：保证线程安全。

这是最简单的生产者—消费者模型。

总结：一二三

  • 一：一个交易场所
  • 二：两个角色
  • 三：三种关系（生产者之间—互斥关系；消费者之间—互斥关系；生产者和消费者—互斥同步关系）

代码示例2：（队列实现，信号量实现互斥同步）

信号量：

就是一个计数器，表示资源的个数。

  • p 申请资源，计数 -1
  • v 释放资源，计数器 +1
  • 当计数器是 0，再去 p 操作就会阻塞

用信号量：

表示互斥：P  V 操作在同一个函数中

表示同步：P  V 操作不在同一个函数中

#pragma once

#include <stdio.h>
#include<pthread.h> //头文件
#include <unistd.h>  //sleep头文件
#include <vector>

//同步互斥不一定非要用互斥锁和条件变量
//信号量：就是一个计数器，表示资源的个数。
//p 申请资源，计数 - 1
//v 释放资源，计数器 + 1
//当计数器是 0，再去 p 操作就会阻塞

//信号量表示互斥比较简单，同步就很复杂。

//初始化信号量：
#include <semaphore.h>  //信号量头文件
sem_t sem;

//阻塞队列
//一般是由上限的：队列为空，执行 Pop 会阻塞
//队列满了，执行 Push 会阻塞
template<typename T>
class BlockingQueue
{
public:
	BlockingQueue(int max_size)  //构造函数
		:max_size_(max_size),head_(0),tail_(0),size_(0),
			queue_(max_size){   //queue(max_size)：含义是将元素个数设置为 max_size
		sem_init(&lock_, 0, 1); //初始化信号量
		sem_init(&elm_, 0, 0); //初始化信号量
		sem_init(&blank_, 0, max_size); //初始化信号量
	}
	~BlockingQueue() {  //析构函数
		sem_destory(&lock_);
		sem_destory(&elm_);
		sem_destory(&blank_);
	}

	
	void Push(const T& data) {
		//每次插入元素先申请空格资源，没有空格资源，信号量0，说明满了，不能插入，push中阻塞。
		sem_wait(&blank_);

		sem_wait(&lock_);
		queue_[tail_] = data;
		++head_;
		++size_;
		sem_post(&lock_);

		sem_post(&elm_);   //元素资源 +1
	}

	//data 表示出队列的这个元素
	void Pop(T* data) {
		//每次删除元素先申请元素资源，没有元素资源，信号量0，说明为空，不能删除，pop中阻塞。
		sem_wait(&elm_);

		sem_wait(&lock_);
		*data = queue_[head_];
		++head_;
		--size_;
		sem_post(&lock_);  //这和互斥锁没区别

		sem_post(&blank_);  //空格资源 +1 
	}


private:
	std::vector<T> queue_;
	int head_;
	int tail_;
	int size_;
	int max_tail;
	sem_t lock_;  //信号量  
	sem_t elm_;    //元素个数
	sem_t blank_;	//空格个数
};
//用一个二元信号量(非0 或 1)表示互斥锁
//一个信号量表示当前队列中元素的个数
//一个信号量表示当前队列中空格的个数，
//插入元素就是消耗一个空格资源，释放一个元素资源
//删除元素消耗一个元素资源，释放一个空格资源



/**********************************
***********以上都在头文件中
**********************************/

#include"BlockQueue.hpp"

BlockingQueue<int> queue(100);

//两个角色：生产者/消费者——两个线程
void* Product(void* arg) {
	(void*)arg;
	int count = 0;
	//负责把数据送到的交易场所中
	while (1)	{
		queue.Push(++count);
		usleep(789789);
	}
	return NULL;
}

void* Consume(void* arg) {
	(void*)arg;
	//负责把交易场所中的数据获取出来
	while (1) {
		int count = 0;
		queue.Pop(&count);
		printf("count = %d\n", result);
		usleep(123123);
	}
	return NULL;
}




int main() {
	pthread_t tid1, tid2;
	pthread_create(&tid1, NULL, Product, NULL); //创建新线程
	pthread_create(&tid2, NULL, Consume, NULL);

	pthread_join(tid1, NULL);  //释放资源
	pthread_join(tid2, NULL);

	return 0;
}

结果就会逐条打印：count = 1 ……；重点理解这个过程，方法模型。

生产者消费者模型实现——线程池

/************************************************************************/
/*在头文件中                                                            */
/************************************************************************/

#pragma once
#include <stdio.h>
#include "Blockingqueue.hpp" //之前的队列
#include <vector>
#include<unistd.h>
class Task {
public:
	virtual void Run() { //虚函数
		printf("base Run\n");
	}
	Task();
	~Task() {

	}
protected:
	
private:
	
};

//线程池启动的时候会创建一组进程
//每个线程都需要完成一定的任务（执行一定的代码逻辑，这个逻辑调用者来决定）
//任务就是一段代码，可以用函数来表示
class ThreadPool {
public:
	//n 表示创建线程的数量
	ThreadPool(int n) :queue_(100){
		//创建出若干线程
		for (int i = 0; i < worker_count_;++i) {
			pthread_t tid;
			pthread_creat(&tid, NULL, ThreadEntry, this);
			worker_.push_back(tid);
		}
	}
	virtual ~ThreadPool(){
		//先让线程退出，然后回收
		for (size_t i = 0; i < workers_.size(); ++i) {
			pthread_cancel(workers_[i]);
		}

		for (size_t i = 0; i < workers_.size();++i) {
			pthread_join(workers_[i], NULL);
		}
		
	}

	//使用线程池的时候，就需要调用者加入一些任务，让线程池去执行
	void AddTask(Task* task) {  //添加任务函数
		queue_.Push(task);
	}
	
private:
	BlockingQueue<Task*> queue_;
	int worker_count_;
	std::vector<pthread_t> workers_;

	static void* ThreadEntry(void* arg) {
		ThreadPool* pool = (ThreadPool*)arg;
		while (true) {
			//循环中尝试从阻塞队列中获取到一个任务，并且执行
			Task* task = NULL;
			pool->queue_.Pop(&task);
			//表面是是task*，实际指向 Mytask*
			//执行子类，用户自定义的逻辑
			task->Run();
			delete task;
		}
	}
};



/************************************************************************/
/*                                                                      */
/************************************************************************/

#include "threadpool.hpp"

//这个类是用户自定制，需要依赖那个数据自定义添加修改
class MyTask:public Task {
public:
	MyTask(int id) :id_(id) {

	}
	~MyTask() {

	}
	void Run() {
		//执行用户自定义的逻辑
            printf("id =%d\n",id_);
	}
private:
	int id_;
};


int main() {
	ThreadPool pool( 10);
	for (int i = 0; i < 20;++i) {
		pool.AddTask(new MyTask(i));
	}
	while (1) {
		Sleep(1);
	}
	
	return 0;
}

结果是：打印id =0 ~20的结果

线程池的好处：（和单个线程使用比较）

  • 提前把线程创建好，避免反复的创建销毁线程的开销
  • 线程不必创建太多，复用一个线程完成多个任务
Joker Zxc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
生产者-消费者问题的模拟实现（课设含源代码）.doc
03-03
用进程同步方法解决“生产者-消费者”问题，C或C++语言实现。 1、设计目的 通过研究进程并发和信号量机制，实现生产者-消费者问题的并发控制。 2、设计要求 1）每个生产者和消费者对有界缓冲区进行操作后，即时显示...
Linux生产者消费者问题编程实例
楚小狂
05-16 1259
<br />#include<sys/types.h><br /> #include<linux/sem.h><br /> #include<linux/shm.h><br /> #include<unistd.h><br /> #include<stdio.h><br /> #include<errno.h><br /> #include<time.h><br />#define MAXSHM 5  //定义缓冲区数组的下标变量个数<br /><br />/*        定义3个信号量的内
队列&生产者消费者模型
djbktqw5273的博客
09-16 77
队列 ipc机制：进程通讯 管道：pipe 基于共享的内存空间 队列：pipe+锁 queue from multiprocessing import Process,Queue ### 案例一 q = Queue() q.put('hyc') q.put([1,2,4]) q.put(2) print(q.get()) print(q.get()) print(q.get()) # ...
Python并行编程(六)：多线程同步之queue(队列)实现生产者-消费者模型
weixin_34187862的博客
04-13 359
方便的队列 当我们处理多线程的资源共享时，线程模块的管理会变得很复杂。我们已经看到了，Python线程模块提供了很多同步原语，包括锁、信号量、条件变量、事件等。虽然有这么多的选择，但是使用队列可能会是管理线程同步的最佳拍档。队列使用起来很容易，因为该模块提供了同步的,安全的对序列,包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列PriorityQue...
【新手入门向 浅显易懂】分别用栈和队列实现生产者与消费者模型
登山爱好者
12-16 109
栈实现模型： #include <stdio.h> #include <stdlib.h> #include <time.h> #include <unistd.h> #include <pthread.h> *// 仓库容量* #define STORE_SIZE (20) *// 仓库* char store[STORE_SIZE]; *// 数量* size_t store_cnt = 0; pthread_mutex_t lock; pt
linux下的消费者-生产者模型代码
ryanxw growing
04-09 510
流程 （1）生产者 （2）消费者 代码 #define N 20 typedef int semaphore; int buf[N] = {0}; int in = 0; int out = 0; int productID = 0; semaphore mutex = 1; semaphore proCmutex = 1; int empty = N; int full = 0; ...
ruby线程实现生产者消费者问题示例(队列Queue实现线程同步)
01-20
Ruby线程实现经典的生产者消费者问题，用ruby中的Queue类实现线程同步问题。 代码如下:require “thread” puts “ProAndCon” queue = Queue.new #用队列Queue实现线程同步 producer = Thread.new do 10....
Lua编程示例（八）：生产者-消费者问题
09-21
主要介绍了Lua编程示例（八）：生产者-消费者问题,本文直接给出实例代码,需要的朋友可以参考下
Java实现简易生产者消费者模型过程解析
08-19
主要介绍了Java实现简易生产者消费者模型过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python之生产者消费者模型实现详解
09-18
主要介绍了python之生产者消费者模型实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Linux系统----生产者和消费者模型及实现
DX_Jone的博客
09-20 381
本文重点： 生产者和消费者模型： 信号量的原理及实现流程： 一.生产者和消费者模型及实现原理： 1.锁等待： 我们知道在实现线程间同步的过程中条件变量通过提供线程等待与唤醒线程的实现线程同步，用户在判断条件不满足的情况下提供等待功能，线程什么时候等待，需要一个判断条件；而这个判断条件也是一个临界资源，条件变量的条件判断应该是一个循环判断： 多个顾客线程若被唤醒，只有一个顾客可以加锁，其他的顾客...
操作系统设计之Linux下的生产者-消费者模型
摩尔的博客
03-03 951
开学第一个礼拜就开始验收操作系统设计，很醉，在家效率基本为负，所以加班加点和小伙伴们合力完成这个设计，因为二次开发更具性价比，所以本次参考的博文有： System V 信号量（生产者与消费者模型） 设计要求 设置两类进程/线程，一类为生产者，一类为消费者; 建立缓冲区的数据结构，应用System V信号量机制实现互斥访问； 以读取配置文件的方式配置生产者和消费者进程参数（个数，生产/消...
线程＋栈 简单实现 生产者消费者关系
veivei5521的专栏
07-29 161
//生产 package test_produce; public class Produce implements Runnable{ Stack_used su; public Produce(){} public Produce(Stack_used su){ this.su = su; } //这里以生产100次为例 public void ...
Linux系统编程---生产者消费者模型
shanghx_123的博客
02-25 463
生产者消费者模型(PC模型） 生产者消费者模型，其实已经很熟悉了，但真正让程序把它跑起来，这里面还有不少细节需要我们注意。 生产者消费者模型，可以归结为一个123，即1个场所，2个对象，3种关系。 它的过程就是 一个生产者生产数据放进缓冲池，消费者从缓冲池中取数据消费，在这期间，生产者生产数据和消费者消费数据两者不能同时进行，即放的时候不能拿，拿的时候不能放，必须是其中一个操作结束之后，才可以进行...
linux中生产者消费者程序,Linux下生产者消费者 实现
weixin_28958733的博客
05-07 172
#include #include #include #include #define MAXLINE (32)struct user_data{unsigned int n_size;char line[MAXLINE];};struct task{struct user_data *data;struct task *next;};struct task *head = NULL,*tail...
进程线程对比总结以及对于生产者消费者的场景分析
hei我在这
06-26 298
进程是一个正在执行的程序，是在计算机上执行的程序实例，是能分配给处理器并由处理器执行的实体。进程信息在Linux下被放在一个叫做task_struct的结构体里。在多线程的情况下，进程通常被定义为资源分配的单位和保护的单位。线程在Linux下也叫做轻量级进程，是程序执行的最小单位。线程是存在于进程中，每个线程都有线程执行状态，在运行时会保存线程的上下文，具有独立的执行栈，并且有用于每个线程局部变量...
生产者消费者模型与多线程
zjgyjd的博客
03-01 293
生产者生产商品,消费者进行消费在这个过程中有一个强耦合问题,消费者有需求时可能生产者并没有生产;为了解决这个问题在生产者和消费者之间加入一个阻塞队列,先通知生产者生产一定库存,然后进入等待当消费者消费完后消费者等待生产者再次工作; 在多线程中要达到这个目的就要借助wait()和notify()这两个属于Object类的方法,线程中的sleep()和wait()有着很大区别; sleep()是Th...
架构设计：生产者-缓存队列-消费者（2）
07-20 489
[1]：如何确定数据单元？ 既然前一个帖子已经搞过扫盲了，那接下来应该开始聊一些具体的编程技术问题了。不过在进入具体的技术细节之前，咱们先要搞明白一个问题：如何确定数据单元？只有把数据单元分析清楚，后面的技术设计才好搞。 ★啥是数据单元 何谓数据单元捏？简单地说，每次生产者放到缓冲区的，就是一个数据单元；每次消费者从缓冲区取出的，也是一个数据单元。对于前一个帖子中寄信的例子，我们可以把每一封...
架构设计：生产者-缓存队列-消费者（1）
07-18 1080
  原文：http://www.cnblogs.com/fgcs/p/4772655.html [0]：概述 今天打算来介绍一下“生产者／消费者模式”，这玩意儿在很多开发领域都能派上用场。由于该模式很重要，打算分几个帖子来介绍。今天这个帖子先来扫盲一把。如果你对这个模式已经比较了解，请跳过本扫盲帖，直接看下一个帖子（关于该模式的具体应用）。 看到这里，可能有同学心中犯嘀咕了：在四人帮（GO...
利用多线程编程技术实现生产者-消费者问题
最新发布
05-09
生产者-消费者问题是一个经典的多线程并发问题，主要涉及到生产者线程和消费者线程之间的协作与同步。在这个问题中，生产者线程负责生产数据，并将数据存入一个共享的缓冲区中，而消费者线程则从缓冲区中取出数据进行消费。为了避免生产者和消费者线程之间的竞争条件和死锁问题，需要使用线程同步技术。 下面是一个使用 Python 语言实现的生产者-消费者问题的示例代码： ```python import threading import time import random # 缓冲区大小 BUFFER_SIZE = 5 # 共享的缓冲区 buffer = [] # 生产者线程 class ProducerThread(threading.Thread): def run(self): global buffer while True: # 生产一个随机数 item = random.randint(1, 10) print("生产者生产了数据：", item) # 获取锁 lock.acquire() # 如果缓冲区已满，等待消费者线程消费数据 while len(buffer) >= BUFFER_SIZE: print("缓冲区已满，生产者等待...") lock.wait() # 将数据存入缓冲区 buffer.append(item) print("生产者将数据存入缓冲区：", buffer) # 释放锁 lock.release() # 随机等待一段时间 time.sleep(random.randint(1, 3)) # 消费者线程 class ConsumerThread(threading.Thread): def run(self): global buffer while True: # 获取锁 lock.acquire() # 如果缓冲区为空，等待生产者线程生产数据 while len(buffer) == 0: print("缓冲区为空，消费者等待...") lock.wait() # 从缓冲区取出数据进行消费 item = buffer.pop(0) print("消费者消费了数据：", item) # 释放锁 lock.release() # 随机等待一段时间 time.sleep(random.randint(1, 3)) # 创建锁 lock = threading.Condition() # 创建生产者线程和消费者线程 producer_thread = ProducerThread() consumer_thread = ConsumerThread() # 启动线程 producer_thread.start() consumer_thread.start() # 等待线程结束 producer_thread.join() consumer_thread.join() ``` 在这个示例代码中，我们使用了 Python 中的 Condition 类来实现线程同步和协作。在生产者线程中，如果缓冲区已满，则使用 wait() 方法等待消费者线程消费数据；在消费者线程中，如果缓冲区为空，则使用 wait() 方法等待生产者线程生产数据。当生产者线程向缓冲区中添加数据或消费者线程从缓冲区中取出数据时，需要使用 acquire() 方法获取锁，以避免竞争条件的发生。 需要注意的是，在生产者-消费者问题中，线程同步和协作是非常重要的，如果实现不当，将会导致死锁、竞争条件等问题。因此，在实际开发中，需要仔细设计和测试多线程程序，以确保程序的正确性和稳定性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值