操作系统实验 生产者与消费者问题代码

#include "stdafx.h"

#include "windows.h"

#include "fstream.h"

#include "string"

#include "conio.h"

#define MAX_BUFFER_NUM 10

#define INTE_PER_SEC 1000

#define MAX_THREAD_NUM 64

struct ThreadInfo

{

int serial;

char entity;

double delay;

int thread_request[MAX_THREAD_NUM];

int n_request;

};

CRITICAL_SECTION PC_Critical[MAX_BUFFER_NUM]; int Buffer_Critical[MAX_BUFFER_NUM]; ThreadInforThread_Info[MAX_BUFFER_NUM]; HANDLE empty_semaphore;

HANDLE h_mutex;

DWORD n_Thread = 0;

DWORD n_Buffer_or_Critical;

HANDLE h_Semaphore[MAX_THREAD_NUM];

void Produce (void *p);

void Consume (void *p);

bool IfInOtherRequest(int);

int FindProducePosition();

int FindBufferPosition(int);

int main(void)

{

DWORD wait_for_all;

ifstream inFile;

for (int i=0;i

Buffer_Critical[i] = -1;

for (int j=0;j

for (int k=0;k

Thread?_Info[j].thread_request[k] = -1;

Thread_Info[j].n_request = 0;

}

for (i=0;i

inFile.open("test.txt")

inFile>>n_Buffer_or_Critial;

inFile.get();

printf("输入文件是：\n")'

printf ("%d\n",(int )n_Buffer_or_Critial);

while(inFile){

inFile >> Thread_Info[n_Thread].serial;

inFile >> Thread_Info[n_Thread].entity;

inFile >> Thread_Info[n_Thread].delay;

char C ;

inFile.get(C);

while (C!'\n'&&!inFile.eof()){

inFile>>

Thread_Info[n_Thread].thread_request [Thread_Info[n_Thread].n_request++];

inFile.get(C);

}

n_Thread++;

}

for (j=0;j<(int)n_Thread;j++){

int Temp_serial = Thread__Info[j].serial;

char Temp_ entity= Thread__Info[j].entity;

double Temp_delay = Thread__Info[j].delay;

printf ("\n thread%2d%c%f",Temp_serial,Temp_entity,Temp_delay);

int Temp_request = Thread_Info[j].n_request;

for (int k=0;k

printf("%d ",Thread_Info[j].thread_request[k]);

cout<

}

printf("\n\n");

empty_semaphore=CreateSemaphore(NULL,n_Buffer_or_Critical,n_Buffer_or_Critical,"semaphor e_for_empty");

h_mutex = CreateMutex(NULL,FALSE,"mutex_for_update");

for (j=0;j<(int)n_Thread;j++){

std::string lp = "semaphore_for_produce _";

int temp = j;

while(temp){

char c = (char)(temp%10);

lp+=c;

temp/=10;

}

h_Semaphore [j+1]=CreateSemaphore(NULL,0,n_Thread,lp.c_str());

for (i=0;i<(int)n_Thread;i++){

if(Thread_Info[i].entity == 'p')

h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Produce),

&(Thread_Info[i]),0,NULL);

else

h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE))(Consume),

&(Thread_Info[i]),0,NULL);

}

wait_for_all = WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1);

printf("\n\nALL producer and consumer have finished their work.\n");

printf ("Press any key to quit!\n");

_getch();

return 0;

}

bool IfInOtherRequest(int req)

{

for (int i=0;i

for (int j=0;j

if(Thread_Info[i].thread_request[j] == req)

return TRUE;

}

int FindProducePosition()

{

int EmptyPosition;

for(int i=0;i

if(Buffer_Critical[i] == -1){

EmptyPosition = i;

Buffer_Critical[i] == -2;

break;

}

return EmptyPosition;

}

int FindBufferPosition(int propos)

{

int Temppos;

for (int i=0;i

Temppos = i;

break;

}

return Temppos;

}

void produce(void*)

{

DWORD wait_for_semaphore,wait_for_mutex,m_delay;

int m_serial;

m_serial = ((ThreadInfo*)(p))-serial;

m_delay = (DWORD)(((ThreadInfo*)(p))->delay *INTE_PER_SEC);

Sleep(m_delay);

printf ("producer %2d sends the produce require.\n",m_serial);

wait_for_semaphore= WaitForSingleObject(enpty_semaphore,-1);

wait_for_mutex = WaitForSingleObject(h_mutex,-1);

int producepos = FindProducePosition();

ReleaseMutex(h_mutex);

prientf("producer %2d begin to produce at position %2d.\n",m_serial,producepos);

Buffer_Critical[producepos]=m_serial;

printf("producer %2d finish producing :\n ",m_serial);

printf("position[%2d]:%3d \n",producepos,Buffer_Clitical [produce-pos]);

ReleaseSemaphore(h_Semaphore[m_serial],n_Thread,NULL);

}

void Consum(void*p)

{

DWORD wait_for_semaphore.m_delay;

int m_serial,m_requestNUM;

int m_thread_request[MAX_THREAD_NUM];

m_serial = ((ThreadInfo*)(p))->serial;

m_delay = (DWORD)(((ThreadInfo*)(p))->delay*INTE_PER_SEC);

m_requestNum=((ThreadInfo*)(p))->n_request;

for (int i=0;ithread_request[i]);

sleep(m_delay);

for(i=0;i

printf("Consumer %2d request to consume %2d product\n",m_serial,m_thread_request[i]);

wait_for_semaphore= WaitForSingleObject(h_Semaphore[m_thread_request[i]],-1;

int Bufferpos= FindBufferPosition(m_thread_request[i]);

EnterCriticalSection(&PC_Critical[Bufferpos]);

printf "Consumer%2d begin to consum %2d product \n",m_serial,m_thread_request[i]);

((ThreadInfo*)(p))->thread_request[i]=-1;

if(!IfInOtherRequest(m_thread_request[i])){

Buffer_Critical[Bufferpos]= -1;

printf("Consumer%2d finish consuming %2d:\n",m_serial,m_thread_request[i]);

rtintf(" position [%2d]:%3d.\n",Bufferpos,Buffer_Critical[Buffer-pos]);

ReleaseSemaphore(empty_semaphore,1,NULL);

}

else{

printf ("Consumer %2d finish consuming product %2d\n",m_serial,m_thread_request[i]);

}

LeaveCriticalSection(&PC_Critical[Bufferpos]);

}

}