Linux中生产与消费者模型、环形生产与消费者模型、线程池

最新推荐文章于 2023-12-02 23:22:20 发布
最新推荐文章于 2023-12-02 23:22:20 发布
阅读量169 收藏
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YIUECHEN/article/details/103365893
版权

生产者与消费者模型

通过一个容器来解决生产者与消费者之间的强耦合问题：
生产者与消费者之间不直接通讯，而是通过无锁阻塞队列来进行通讯；生产者生产完数据后不用等待消费者处理，而是直接放到阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列取。 阻塞队列相当于一个缓冲区，平衡了生产者与消费者的处理能力，用来解耦合。

优点：
  1. 支持忙闲不均
  2. 支持并发（先保证安全队列）
  3. 解耦合（让两个模块间减少关联）
BlockingQueue代码实现

注意：

  1. 生产者或消费者之间具备互斥关系
  2. 生产者与消费者之间具备同步+互相hi关系
  3. 先进先出
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<queue>
#include<pthread.h>
#include<unistd.h>
using namespace std;

#define MAX_QUE 10
#define MAX_THR 4

class BlockQueue{
	private:
		queue<int> _queue;
		int _capacity;
		pthread_cond_t _cond_pro;//生产者条件变量
		pthread_cond_t _cond_con;//消费者条件变量
		pthread_mutex_t _mutex;
	public:
		BlockQueue(int que_num=MAX_QUE):_capacity(que_num){
			pthread_mutex_init(&_mutex,NULL);
			pthread_cond_init(&_cond_pro,NULL);
			pthread_cond_init(&_cond_con,NULL);
		}
		~BlockQueue(){
			pthread_mutex_destroy(&_mutex);
			pthread_cond_destroy(&_cond_pro);
			pthread_cond_destroy(&_cond_con);
		}
		bool QueuePush(int &data){
			pthread_mutex_lock(&_mutex);
			while(_queue.size()==_capacity){
				pthread_cond_wait(&_cond_pro,&_mutex);
			}
			_queue.push(data);
			pthread_mutex_unlock(&_mutex);
			pthread_cond_signal(&_cond_con);
			return true;
		}
		bool QueuePop(int &data){
			pthread_mutex_lock(&_mutex);
			while(_queue.size()==0){
				pthread_cond_wait(&_cond_con,&_mutex);
			}
			data=_queue.front();
			_queue.pop();
			pthread_mutex_unlock(&_mutex);
			pthread_cond_signal(&_cond_pro);
			return true;
		}
};
void *consumer(void *arg){
	BlockQueue *queue=(BlockQueue*)arg;	
	while(1){
		int data;
		queue->QueuePop(data);
		printf("%p..get a data:%d\n",pthread_self(),data);
	}
	return NULL;
}
void *product(void *arg){
	int data=0;
	BlockQueue *queue=(BlockQueue*)arg;	

	while(1){
		queue->QueuePush(data);
		printf("%p__put a data:%d\n",pthread_self(),data++);
                sleep(1);
	}
	return NULL;
}
int main(){
	BlockQueue bq;
	pthread_t ptid[MAX_THR],ctid[MAX_THR];

	int ret;
	for(int i=0;i<MAX_THR;i++){
		ret=pthread_create(&ptid[i],NULL,product,(void*)&bq);
		if(ret!=0){
			cerr<<"pthread create error"<<endl;
			return -1;	
		}
	}
	for(int i=0;i<MAX_THR;i++){
		ret=pthread_create(&ctid[i],NULL,consumer,(void*)&bq);
		if(ret!=0){
			cerr<<"pthread create error\n"<<endl;
			return -1;	
		}
	}

	for(int i=0;i<MAX_THR;i++){
		pthread_join(ptid[i],NULL);
		pthread_join(ctid[i],NULL);
	}
	return 0;
}

环形生产与消费者模型

#include<iostream>
#include<string>
#include<stdio.h>
#include<unistd.h>
#include<vector>
#include<semaphore.h>
#include<pthread.h>
using namespace std;
#define MAX_THR 4
#define MAX_QN 10
class RingQueue{
	private:
		vector<int> _queue;
		int _capacity;
		int _read;
		int _write;
		sem_t sem_lock;
		sem_t sem_con;
		sem_t sem_pro;
	public:
		RingQueue(int max_que=MAX_QN):_capacity(max_que),_queue(max_que),_write(0),_read(0){
			sem_init(&sem_lock,0,1);
			sem_init(&sem_con,0,0);
			sem_init(&sem_pro,0,max_que);

		}
		~RingQueue(){
			sem_destroy(&sem_lock);
			sem_destroy(&sem_pro);
			sem_destroy(&sem_con);
		}
		bool QueuePush(int &data){
			sem_wait(&sem_pro);
			sem_wait(&sem_lock);
			_queue[_write]=data;
			_write=(_write+1)%_capacity;
			sem_post(&sem_lock);
			sem_post(&sem_con);
			return true;
		}
		bool QueuePop(int &data){
			sem_wait(&sem_con);
			sem_wait(&sem_lock);
			data=_queue[_read];		        
			_read=(_read+1)%_capacity;
			sem_post(&sem_lock);
			sem_post(&sem_pro);
			return true;              
		}

};
void *consumer(void *arg){//消费者执行函数
	RingQueue *queue=(RingQueue*)arg;
	while(1){
		int data;
		queue->QueuePop(data);
		printf("%p***get a data:%d\n",pthread_self(),data);
	}
	return NULL;
}

void *productor(void *arg){//生产者执行函数
	RingQueue *queue=(RingQueue*)arg;
	int i=0;	
	while(1){
		queue->QueuePush(i);
		printf("%p---put a data:%d\n",pthread_self(),i++);
		sleep(1);	
	}
	return NULL;
}
int main(){
	RingQueue queue;
	pthread_t ctid[MAX_THR],ptid[MAX_THR];
	for(int i=0;i<MAX_THR;i++){
	      int ret=pthread_create(&ctid[i],NULL,consumer,(void*)&queue);
		if(ret!=0){
			printf("pthread create error\n");
			return -1;	
		}
	}
	for(int i=0;i<MAX_THR;i++){
	      int ret=pthread_create(&ptid[i],NULL,productor,(void*)&queue);
	   	  if(ret!=0){
		    	printf("pthread create error\n");
			    return -1;		
		}
	}

	for(int i=0;i<MAX_THR;i++){
		pthread_join(ctid[i],NULL);
		pthread_join(ptid[i],NULL);
	}
	return 0;
}

线程池

提前创建一批线程（最大数量限制），以及一个线程安全的任务队列，当大量的请求到来后，被添加到任务队列中，而线程池中的线程再不断从任务队列中获取任务进行处理即可。

作用
  1. 避免大量线程的频繁创建与销毁所带来的时间成本。
  2. 避免峰值压力下的线程创建过多导致的导致资源耗尽的风险。（创建有最大数量上限）
实现方法
  1. 一个以上的线程+线程安全的队列
  2. 使用C++封装一个线程池类，向外提供简单的线程池操作接口
代码实现
#include<iostream>
#include<queue>
#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<stdlib.h>
using namespace std;

//任务类的实现
typedef void(*TaskHandler)(int data);
class ThreadTask{
	private:
		int _data;
		TaskHandler _handler;

	public:
		ThreadTask(){}

		ThreadTask(int data,TaskHandler handler)//构造时给定参数
			:_data(data),_handler(handler){}

		void SetTask(int data,TaskHandler handler){
			_data=data;
			_handler=handler;
		}

		void Run(){
			_handler(_data);
		}
};

//线程池的实现
#define MAX_THR 5
class ThreadPool{
	private:
		int thr_num;//线程池中线程的最大数量
		queue<ThreadTask> _task_queue;//队列
		pthread_mutex_t _mutex;//保护队列的安全操作
		pthread_cond_t _cond_con;//实现队列的同步操作---消费者
		pthread_cond_t _cond_pro;//实现队列的同步操作---生产者
		
	private:
		static void *thr_start(void *arg){//只能洋浦一个函数，如果没有static表示是个类成员函数
			ThreadPool *pool=(ThreadPool*)arg;
			while(1){
				pool->ThreadLock();
				while(pool->TaskIsEmpty()){
					pool->ThreadWait();
				}
				ThreadTask tt;
				pool->QueuePop(tt);		
				pool->ThreadUnlock();
				tt.Run();
			}		
			return NULL;
		}
		
	public:	
		void ThreadLock(){
			pthread_mutex_lock(&_mutex);
		}
		void ThreadUnlock(){
			pthread_mutex_unlock(&_mutex);
		}
		void ThreadWait(){
			pthread_cond_wait(&_cond_con,&_mutex);
		}
		void ThreadWakeUp(){
			pthread_cond_signal(&_cond_con);
		}
		bool TaskIsEmpty(){
			return _task_queue.empty();
		}
		bool QueuePop(ThreadTask &tt){
			tt=_task_queue.front();
			_task_queue.pop();
			return true;                
		}
	public:
		ThreadPool(int max_thr=MAX_THR)
			:thr_num(max_thr){}
			
		//线程池的初始化	
		bool PoolInit(){
			pthread_mutex_init(&_mutex,NULL);//锁、条件变量的初始化一定要放在线程创建之前
			pthread_cond_init(&_cond_con,NULL);
			pthread_cond_init(&_cond_pro,NULL);
			
			for(int i=0;i<thr_num;i++){
				pthread_t tid;
				int ret=pthread_create(&tid,NULL,thr_start,(void*)this);
				if(ret!=0){
					cerr<<"pthread create error\n";
					return false;
				}
				pthread_detach(tid);
			}
			return  true;
		}
        //向任务队列中添加队列
		bool TaskPush(ThreadTask &tt){
			pthread_mutex_lock(&_mutex);
			_task_queue.push(tt);
			pthread_mutex_unlock(&_mutex);
			pthread_cond_signal(&_cond_con);
			return true;
		}
};

//调用函数
void test(int data){
	srand(data);
	int sec=rand()%5;
	printf("thread:%p---get data:%d,sleep %d sec\n",pthread_self(),data,sec);
	sleep(sec);
}

int main(){
	ThreadPool pool;
	pool.PoolInit();
	for(int i=0;i<10;i++){
		ThreadTask task(i,test);
		pool.TaskPush(task);
	}
	while(1){
		sleep(1);
	}
	return 0;
}
星光不负赶路人_
关注
专栏目录
Go 并发模型
程序员光剑
08-03 1455
Concurrency is the ability of a program to perform multiple tasks at once”（并发是指一个程序能够同时执行多个任务）。并发可以帮助我们提高处理效率、节省资源、增加吞吐量和改善用户体验。但是同时，也会引入很多新的问题。本文将带领你一起了解并发模型中的重要概念和原理，以及如何在实际项目中正确运用这些知识。
Linux线程池
赵小厨的博客
08-20 210
什么是池？ 池是一组资源的集合，这组资源在服务器启动之初就被创建并初始化 开始处理客户请求的时候，如果它需要相关的资源，就可以直接从池中获取 服务器处理完一个客户连接后，可以把相关的资源放回池中 为什么要创建线程池？ 当有客户端连接时，创建耗时为：线程时间+处理时间+销毁线程时间 （耗时T1+T2+T3） 若需要大量的线程来完成任务，且完成任务的时间比较短，这样花费在T1和T3上面的时间比较...
linux pool函数,Linux 线程池，执行任务队列（生产者消费者模型）
weixin_42361834的博客
05-09 269
两个结构体线程池线程池结构体包含任务队列和线程数组两个结构体，和一些锁，条件变量，长度等成员任务任务队列是一个链表结构，链表中每个任务是一个函数指针做任务句柄任务队列是线程和主程序所共享的共享资源，所以要考虑互斥的对任务队列中入队和出对进行操作。主程序向任务队列中加任务，线程从任务队列中取任务，考虑用条件变量来模拟操作系统中的生产者消费者模型，即pv操作四个函数void pool_init(int...
linux生产者消费者模型---线程池的实现实现
qq_43205670的博客
04-27 1277
生产者和消费者模型:通过一个容器来解决生产者和消费者的强耦合问题,生产者和消费者彼此直接不直接通讯,而是通过组设队列来进行通讯,所以生产者产生数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里去,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力,这个阻塞队列就是出来给生产者和消费者解耦的 生产者 ------------缓冲区-----------...
linux --线程（五）线程池模型
e我所欲也的博客
04-29 417
文章目录线程池（thread pool）线程池组成部分线程池生产者消费者模式示例 线程池（thread pool） 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内...
C语言环形队列线程池,【AQS】队列和【Disruptor】环形队列
weixin_29923451的博客
05-22 365
1：使用场景我们在编码的过程中，经常会碰到这样一种场景：需要使用多线程的任务这个任务需要同步，不能并发我们想要这些线程一个个乖乖的排队去执行，别串来串去贼烦这个时候，你可以使用synchronized关键字加锁，当然我们也可以使用jdk1.5之后的juc的各种工具，当然这些juc的工具其实都是基于我们的aqs队列。2：aqs队列很多好用的juc的工具，我们这里就不写了，我们这里就来分析aqs队列我...
【Linux】消费者与生产者模型！！
Doctor_xiong的博客
04-07 356
POSIX信号量 信号量的类型：sem_t 初始化信号量函数：int sem_init(sem_t* sem,int pthread,unsigned value); sem:信号量名 pthread：0表示线程间共享，非0表示进程间共享 value：信号量初始值 销毁信号量函数：int sem_destrpy(sem_t* sem); 等待信号量：int sem_wait(sem_...
Linux：多线程——生产者与消费者模型
qq_43825377的博客
03-15 390
Linux：多线程——生产者与消费者模型二级目录三级目录 代码： #include <stdio.h> #include <stdlib.h> #include <unistd.h&g
生产者消费者模型、信号量、线程池以及单例模式的实现
liwenjie0的博客
07-23 330
生产者消费者模型！！---对典型的应用场景设计的解决方案 生产者与消费者模型应用场景：有线程不断的生产数据，有线程不断的处理数据。 数据的生产与数据的处理：放在同一个线程中完成，因为执行流只有一个，那么肯定是生产一个处理一个，处理一个后才能生产一个，这样的话依赖关系太强---如果处理比较慢，也会拖的生产速度慢下来。 因此将生产与处理放到不同的执行流中完成，中间增加一个数据缓冲区，作为中间的数据缓冲场所。 生产者与消费者解决的问题：1.解耦和 （将各个功能分离）2.支持忙闲不均/3.支持并发.
Linux线程安全，死锁，生产消费模型，线程池
最新发布
徐凤年llll的博客
12-02 915
然后你第二天准备去学习了，卷的不行，直接凌晨三点就跑过来，拿着钥匙进入自习室上自习了，然后卷了3小时之后，你想出来上个厕所，一打开门发现外面站的一堆人，都在叽叽喳喳的讨论谁先来的，怎么来的这么早？等你回来的时候，你又打开门，又来里面上了3小时自习，你感觉自己饿的不行了，在不吃饭就饿死在里面了，所以你打开门，准备出去吃饭了，然后突然你自己感觉负罪感直接拉满，我凌晨3点好不容易抢到自习室，现在离开是不太亏了，所以你又打开自习室回去上自习去了，别人当然竞争不过你呀！即为3种关系，两个角色，1个交易场所。
JAVA并发编程 之 LMAX Disruptor使用实例（高效解决生产者与消费者问题）
热门推荐
二一点
04-13 1万+
什么是Disruptor？Disruptor是一个开源的JAVA框架，它被设计用于在生产者—消费者（producer-consumer problem，简称PCP）问题上获得尽量高的吞吐量（TPS）和尽量低的延迟。Disruptor是LMAX在线交易平台的关键组成部分，LMAX平台使用该框架对订单处理速度能达到600万TPS，除金融领域之外，其他一般的应用中都可以用到Disruptor，它可以带来...
Linux C系统编程：使用线程池实现cp命令
08-27
在Linux系统编程中，C语言线程池的实现是一个高级话题，它涉及到多线程、进程间通信（IPC）和任务调度等复杂概念。本文将深入探讨如何利用线程池来实现一个类似于`cp`命令的功能，即高效地进行文件复制。 首先，...
C语言环形队列线程池,队列——数组实现（循环队列）
weixin_33614878的博客
05-22 363
#include #include #include #include using namespace std;using ElemType = int;const int MAXSIZE = 20;// 队列结构class Queue {public:ElemType data[MAXSIZE];int front;// 队首int rear;// 队尾};// 初始化队列void initQu...
POSIX信号量&&生产者消费者模型&&线程池
GJwalkhard的博客
04-30 255
生产者消费者模型 1.概念的引入 在日常生活中，当我们缺少生活用品是，我们会去超市购物，当我们买走超市货架上的东西，超市则会补充货架上的货物，那么超市的货物是从哪来的呢？不错，他们会有自己的供货商。那么我们是以怎样的身份进入超市呢？相信每个人都知道自己是以消费者的角色去的，生产者毫无疑问就是供货商，那么将我们与供货商这二者联系到一起的超市在这里面又扮演了什么样的角色呢？仔细想想便不难得出超市就是交易场所。 2.为什么要使用生产者消费者模型 3. 生产者消费者模型的理解原则 POSIX信号量 1.作用 2.相
线程池 队列生产者消费者模型实现
马上行动
08-23 2328
static { try { ExecutorService pool = null; try { // 创建一个可重用固定线程数的线程池 pool = Executors.newFixedThreadPool(10); // 创建10个任务
Linux中常用的vim三种模式（普通模式、插入模式、底行模式）
YIUECHEN的博客
10-14 3509
shell命令以及运行原理 shell:操作系统=内核+应用
操作系统是什么？
YIUECHEN的博客
04-15 2962
首先我们要明白我们所使用的计算机是由许多硬件组成的，如：显示器、CPU、内存、硬盘、键盘等，最初发明计算机的目的是为了帮助人类进行大量的计算与逻辑任务。可是我们不可以直接使用这些计算机硬件，需要在计算机硬件上包上一层软件，我们使用这些软件来完成一些特定的任务。 操作系统（Operation System, 简称OS），就是介于计算机硬件与应用软件之间的一层软件（或者说接口），便于我们高效的使用计算...
操作系统课程设计：生产者消费者问题与银行家算法实践
生产者消费者问题是并发编程中一个经典的同步问题，用于模拟生产者进程生成数据并放入缓冲区，而消费者进程从缓冲区取出数据的场景。银行家算法则是用于避免系统死锁的一种策略，确保资源的合理分配。" 在这个课程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值