生产者消费者算法模拟 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;
}