生產者消費者算法模擬 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;
}