生产者消费者算法模拟 c++

 

 

运行结果

 

流程图

废话不多说，直接上代码 

#include<iostream>
#include <string> 
#include <unistd.h> //sleep函数库文件

#include<process.h>
#include<windows.h>//句多线程柄库文件 
#define n 10 //缓冲区大小 
#define sleeptime 2 //控制生产者消费者的生产和消费速度，便于演示观察 
#define executime 3000//模拟生产消费者算法的时间长 
using namespace std;

typedef handle semaphore; //互斥信号量句柄 
typedef int item; //缓冲池中产品类型

item buffer[n] = {0}; //定义缓冲池，并全部置空 
int in = 0; 
int out = 0;
int counter = 0;//每当生产者进程向缓冲池中投放（或取走）一个产品后,使counter加1(或减1)。
semaphore mutex , empty , full ;//定义互斥信号量句柄

//模拟算法中涉及的课外知识

//handle winapi createsemaphore( _in_opt_lpsecurity_attributes lpsemaphoreattributes ,_in_long linitialcount, _in_ long lmaximumcount,_in_opt_? lpctstr lpname
//);
//第一个参数：安全属性，如果为null则是默认安全属性
//第二个参数：信号量的初始值，要>=0且<=第三个参数
//第三个参数：信号量的最大值
//第四个参数：信号量的名称
//
//返回值：指向信号量的句柄，如果创建的信号量和已有的信号量重名，那么返回已经存在的信号量句柄
//
//dword waitforsingleobject(handle hhandle,dword dwmilliseconds);
//
//第一个参数：等待对象的 handle（代表一个核心对象）。
//第二个参数：等待的最长时间。时间终了，即使 handle尚未成为激发状态，此函数也要返回。此值可以是0（代表立刻返回），也可以是 infinite代表无穷等待。
//
//bool winapi releasesemaphore( _in_ handle hsemaphore,_in_ long lreleasecount,_out_opt_ lplong lppreviouscount);
//第一个参数：信号量句柄
//第二个参数：释放后，信号量增加的数目
//第三个参数：信号量增加前的值存放的地址，如果不需要则为null
//返回值：释放是否成功
//void wait(semaphore &s)
//{	
//	while (s<=0);
// s=s-1;
//}
//
//void signal(semaphore &s)
//{ 
//	s=s+1;
//}
//

void display(string str)
{
cout<<str<<endl;
cout<<"缓冲池:";
for(int i=0;i<n;i++){
cout<<buffer[i]<<' ';
// sleep(1); 减慢输出速度	 
}
cout<<endl;
cout<<"counter:"<<counter<<endl<<endl;
//cout<<" mutex:"<<mutex<<" empty:"<<empty<<" full:"<<full<<endl<<endl; 由于是互斥信号量句柄，无法直接访问其值 
}

unsigned __stdcall producer(void*)
{
do{
waitforsingleobject(empty, infinite);//等待同步信号量empty
waitforsingleobject(mutex, infinite);//等待互斥信号量mutex
item nextp=1;	
buffer[in]=nextp;
in=(in+1)%n;
counter++;
display("生产一件产品");

sleep(sleeptime); 
releasesemaphore(mutex, 1, null);//释放互斥信号量mutex
releasesemaphore(full, 1, null);//释放同步信号量full	

}while(1);
return 1;
}

unsigned __stdcall consumer(void* )
{
do{
waitforsingleobject(full, infinite);//等待同步信号量full
waitforsingleobject(mutex, infinite);//等待互斥信号量mutex
item nextc=buffer[out]; 
buffer[out]=0;
out=(out+1)%n;
counter--;	
sleep(sleeptime); 
display("消费一件产品");
releasesemaphore(mutex, 1, null);//释放互斥信号量mutex
releasesemaphore(empty, 1, null);//释放信号量	
}while(1);
return 2;
}

int main(){
int buf_max=n;//输入缓冲区大小，整形变量，大于0，建议在10—20之间一个整数 ,这里为定义的宏n 
int producernum; //输入生产者数量，整形变量，建议在4-8，直接，否则太大电脑跑不动，太小生产速度不够 
int consumernum;//输入消费者数量,整形变量,建议小于生产者数量，不要为 0
cout<<"请输入生产者数量:";cin>>producernum;
cout<<"请输入消费者数量:";cin>>consumernum; 
empty = createsemaphore(null, buf_max, buf_max, null); //初值为缓冲池大小，最大为缓冲池大小
full = createsemaphore(null, 0, buf_max, null); //初值为0，最大为缓冲池大小
mutex = createsemaphore(null,1,1,null); //初值为1,最大为1
handle hthproducer[producernum], htconsumer[consumernum];//定义生产者 消费者线程句柄池大小 

//创建线程
int i;

for(i=0;i<producernum;i++)
{
hthproducer[i] = (handle)_beginthreadex(null, 0, producer, null, 0, null);//生产者线程
}

for(i=0;i<consumernum;i++)
{
htconsumer[i] = (handle)_beginthreadex(null, 0, consumer, null, 0, null);//消费者线程
}



//等待子线程结束
for(i=0;i<producernum;i++) 
waitforsingleobject(hthproducer[i], executime);//在时间executime到达后无论是否激活线程，都会关闭线程 
for(i=0;i<consumernum;i++) 
waitforsingleobject(htconsumer[i], executime);//在时间executime到达后无论是否激活线程，都会关闭线程 

//关闭句柄 
for(i=0;i<producernum;i++) 
closehandle(hthproducer[i]);
for(i=0;i<consumernum;i++)
closehandle(htconsumer[i]);

closehandle(empty);
closehandle(full);
closehandle(mutex);	

cout<<"演示完毕，谢谢观看"; 


return 0;
}