下载文档原格式
C语⾔调⽤库函数实现⽣产者消费者问题1 #include<stdio.h>2 #include<stdlib.h>3 #include<semaphore.h>4 #include<pthread.h>5 #include<unistd.h>67#define NumOf_Producer 5 //the max num of producer8#define NumOf_Consumer 10 //the max num of consumer9#define Maxnum 10 // the max num of product10 sem_t Empty_sem; //the goal of whether the num of product is null11 sem_t Full_sem; //the goal of whether the num of product is equal to Maxnum1213 pthread_mutex_t Mutex; //the goal of whether someone use the buff1415int Producer_id = 0;16int Consumer_id = 0;17int NowNumOfProduce = 0;18void *Producer(void *arg) //the thread of producer19 {20int id = Producer_id++;21while(1)22 {23 sleep(0.1);24 sem_wait(&Full_sem); //when it comes to zero ,it means that the num of product is equal to Maxnum25 pthread_mutex_lock(&Mutex); //lock the buff26 NowNumOfProduce++;27 printf("Producerthread %d product one,the num is:%d \n",id%NumOf_Producer,NowNumOfProduce);28 pthread_mutex_unlock(&Mutex);29 sem_post(&Empty_sem); //when it comes to ten ,it means there are ten products can be used by consumer30 }3132return ((void *)0);33 }3435void *Consumer(void *arg)36 {37int id = Consumer_id++;38while(1)39 {40 sleep(0.2);41 sem_wait(&Empty_sem);42 pthread_mutex_lock(&Mutex);43 NowNumOfProduce--;44 printf("Consumerthread %d use product one,the num is:%d \n",id%NumOf_Consumer,NowNumOfProduce);45 pthread_mutex_unlock(&Mutex);46 sem_post(&Full_sem);47 }48return ((void *)0);49 }5051int main()52 {53 pthread_t Con[NumOf_Consumer];54 pthread_t Pro[NumOf_Producer];5556int temp1 = sem_init(&Empty_sem,0,0);57int temp2 = sem_init(&Full_sem,0,Maxnum);58if(temp1&&temp2!=0)59 {60 printf("sem init failed \n");61 exit(1);62 }6364int temp3 = pthread_mutex_init(&Mutex,NULL);6566if(temp3!=0)67 {68 printf("Mutex init failed \n");69 exit(1);70 }7172for(int i=0 ;i<NumOf_Producer;i++)73 {74int temp4 = pthread_create(&Pro[i],NULL,Producer,(void *)&i);75if(temp4!=0)76 {77 printf("thread create failed !\n");78 exit(1);79 }80 }8182for(int i=0;i<NumOf_Consumer;i++)83 {84int temp5 = pthread_create(&Con[i],NULL,Consumer,(void *)&i);85if(temp5!=0)86 {87 printf("thread create failed !\n");88 }89 exit(1);90 }91//destroy the thread92for(int i=0;i<NumOf_Consumer;i++)93 {94 pthread_join(Con[i],NULL);95 }9697for(int i=0;i<NumOf_Producer;i++)98 {99 pthread_join(Pro[i],NULL);100 }101102return0;103 }说明：unisted.h是⽤来调⽤sleep，pthread.h是linux系统下线程编程的库，semaphore.h是使⽤信号灯的函数库，⾄于那些初始化⽅法，wait⽅法，post等可以去查查的。
#include <windows.h>#include <fstream.h>#include <iostream.h>#include <string>#include <conio.h>//声明所需变量int in=0;int out=0;HANDLE h_Thread[20]; //线程数组HANDLE empty_Semaphore; //表示空缓冲区的信号量HANDLE full_Semaphore; //表示空缓冲区的信号量HANDLE mutex;struct data{int ID;//序号char type;//类型，是生产者还是消费者,p or cdouble delay;//线程延迟的时间，对应生产者生产产品的时间或消费者消费产品的时间};data ThreadInfo[20]; //线程信息数组int length; //线程信息数组中实际的线程个数void Produce(void *p);//生产者进程void Consume(void *p);//消费者进程void input(void);int main(void){input();//初始化临界区对象//InitializeCriticalSection(&PC_Critical);empty_Semaphore=CreateSemaphore(NULL,10,10,NULL);full_Semaphore=CreateSemaphore(NULL,0,10,NULL);mutex = ::CreateMutex(NULL,FALSE,NULL);cout<<"下面生产者和消费者开始工作!!"<<endl;cout<<endl;//创建生产者和消费者线程for(int i=0;i<length;i++){if(ThreadInfo[i].type=='p')h_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Produce),&(ThreadInfo[i]), 0,NULL);elseh_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consume),&(ThreadInfo[i]),0,N ULL);}//主程序等待各个线程的动作结束WaitForMultipleObjects(length,h_Thread,TRUE,-1);cout<<endl;::Sleep(1000000);cout<<"所有的生产者和消费者都完成了它们的工作!!"<<endl<<endl;return 0;}//***************************************************************************** ************//生产者进程//***************************************************************************** *************void Produce(void *p){}//***************************************************************************** ************//消费者进程//***************************************************************************** *************void Consume(void *p){//局部变量声明int my_id;double my_delay;//从线程信息数组中获得信息my_id =((data*)(p))->ID;my_delay=((data*)(p))->delay;//开始请求xiaofeicout<<"消费者"<<my_id<<"发出消费请求。
实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
二、实验环境Windows操作系统和Visual C++6.0专业版或企业版三、实验步骤模拟PV操作同步机构，且用PV操作解决生产者——消费者问题。
[提示]：(1) PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：P操作原语P (s)：将信号量s减去1，若结果小于0，则执行原语的进程被置成等待信号量s的状态。
V操作原语V (s)：将信号量s加1，若结果不大于0，则释放一个等待信号量s的进程。
这两条原语是如下的两个过程：procedure p (var s: semaphore);begin s: = s-1;if s<0 then W (s)end {p}procedure v (var s: semaphore);egin s: = s+1;if s 0 then R (s)end {v}其中W（s）表示将调用过程的进程置为等待信号量s的状态；R（s）表示释放一个等待信号量s的进程。
在系统初始化时应把semaphore定义为某个类型，为简单起见，在模拟实习中可把上述的semaphore直接改成integer。
(2) 生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
二、实验环境Windows操作系统和Visual C++专业版或企业版三、实验步骤模拟PV操作同步机构，且用PV操作解决生产者——消费者问题。
[提示]：(1) PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：P操作原语P (s)：将信号量s减去1，若结果小于0，则执行原语的进程被置成等待信号量s的状态。
V操作原语V (s)：将信号量s加1，若结果不大于0，则释放一个等待信号量s的进程。
这两条原语是如下的两个过程：procedure p (var s: semaphore);begin s: = s-1;if s<0 then W (s)end {p}procedure v (var s: semaphore);egin s: = s+1;if s￡0 then R (s)end {v}其中W（s）表示将调用过程的进程置为等待信号量s的状态；R（s）表示释放一个等待信号量s的进程。
在系统初始化时应把semaphore定义为某个类型，为简单起见，在模拟实习中可把上述的semaphore直接改成integer。
(2) 生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
操作系统实验生产者与消费者问题代码#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 64struct 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<max_buffer_num;i++)< p="">Buffer_Critical[i] = -1;for (int j=0;j<max_thread_num;j++)< p="">for (int k=0;k<max_thread_num;k++)< p=""> Thread?_Info[j].thread_request[k] = -1;Thread_Info[j].n_request = 0;}for (i=0;i<="" p="">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",T emp_serial,Temp_entity,T emp_delay);int Temp_request = Thread_Info[j].n_request;for (int k=0;k<temp_request;k++)< p="">printf("%d ",Thread_Info[j].thread_request[k]);cout<<end1;< p="">}printf("\n\n");empty_semaphore=CreateSemaphore(NULL,n_Buffer_or_Cri tical,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);elseh_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUT INE))(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<n_thread;i++)< p="">for (int j=0;j<thread_info[i].n_request;j++)< p="">if(Thread_Info[i].thread_request[j] == req)return TRUE;}int FindProducePosition(){int EmptyPosition;for(int i=0;i<n_buffer_or_critical;i++)< p="">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<n_buffer_or_critical;i++)< p="">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<m_requestnum;i++){< p="">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]);}}</m_requestnum;i++){<></n_buffer_or_critical;i++)<></n_buffer_or_critical;i++)<></thread_info[i].n_request;j++)<></n_thread;i++)<></end1;<></temp_request;k++)<></max_thread_num;k++)<></max_thread_num;j++)<></max_buffer_num;i++)<>。
实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
二、实验环境Windows操作系统和Visual C++6.0专业版或企业版三、实验步骤模拟PV操作同步机构，且用PV操作解决生产者——消费者问题。
[提示]：(1) PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：P操作原语P (s)：将信号量s减去1，若结果小于0，则执行原语的进程被置成等待信号量s的状态。
V操作原语V (s)：将信号量s加1，若结果不大于0，则释放一个等待信号量s的进程。
这两条原语是如下的两个过程：procedure p (var s: semaphore);begin s: = s-1;if s<0 then W (s)end {p}procedure v (var s: semaphore);egin s: = s+1;if s 0 then R (s)end {v}其中W（s）表示将调用过程的进程置为等待信号量s的状态；R（s）表示释放一个等待信号量s的进程。
在系统初始化时应把semaphore定义为某个类型，为简单起见，在模拟实习中可把上述的semaphore直接改成integer。
(2) 生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
二、实验环境Windows操作系统和Visual C++专业版或企业版三、实验步骤模拟PV操作同步机构，且用PV操作解决生产者——消费者问题。
[提示]：(1) PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：P操作原语P (s)：将信号量s减去1，若结果小于0，则执行原语的进程被置成等待信号量s的状态。
V操作原语V (s)：将信号量s加1，若结果不大于0，则释放一个等待信号量s的进程。
这两条原语是如下的两个过程：procedure p (var s: semaphore);begin s: = s-1;if s<0 then W (s)end {p}procedure v (var s: semaphore);egin s: = s+1;if s£0 then R (s)end {v}其中W（s）表示将调用过程的进程置为等待信号量s的状态；R（s）表示释放一个等待信号量s的进程。
在系统初始化时应把semaphore定义为某个类型，为简单起见，在模拟实习中可把上述的semaphore直接改成integer。
(2) 生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
C语言编程模拟生产者和消费者问题（附代码程序）实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语一一同步原语一一所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
二、实验环境Windows操作系统和VisualC++6.0专业版或企业版三、实验步骤模拟PV操作同步机构，且用PV操作解决生产者一一消费者问题。
［提示］:⑴PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：P操作原语P(s):将信号量s减去1,若结果小于0,则执行原语的进程被置成等待信号量s的状态。
V操作原语V(s):将信号量s加1,若结果不大于0,则释放一个等待信号量s的进程。
这两条原语是如下的两个过程:procedurep(vars:semaphore);begi ns:=s-1;ifs<0the nW(s)en d{p}procedurev(vars:semaphore);egin s:=s+1;ifs _Othe nR(s)en d{v}其中W (s)表示将调用过程的进程置为等待信号量s的状态；R (s)表示释放一个等待信号量s的进程。
在系统初始化时应把semaphore定义为某个类型，为简单起见，在模拟实习中可把上述的semaphore直接改成integer。
(2) 生产者一一消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
#include <stdio.h>#include <malloc.h>int processnum=0;struct pcb{int flag;int numlabel;char product;char state;struct pcb* processlink;}*exe=NULL,*over=NULL;typedef struct pcb PCB;PCB* readyhead=NULL,*readytail=NULL;PCB* consumerhead=NULL,*consumertail=NULL; PCB* producerhead=NULL,*producertail=NULL;int productnum=0;int buffersize=100;int full=0,empty=buffersize;char buffer[100];int bufferpoint=0;void linkqueue(PCB* process,PCB**tail);PCB* getq(PCB* head,PCB**tail);bool hasElement(PCB* pro);void display(PCB* p);void linklist(PCB* p,PCB* listhead);void freelink(PCB *linkhead);bool processproc();bool waitempty();bool waitfull();void signalempty();void signalfull();void producerrun();void comsuerrun();bool hasElement(PCB* pro);void linklist(PCB* p,PCB* listhead){PCB* cursor=listhead;while(cursor->processlink!=NULL){cursor=cursor->processlink;}cursor->processlink=p;}void freelink(PCB* linkhead){PCB* p;while(linkhead!=NULL){p=linkhead;linkhead=linkhead->processlink;free(p);}}void linkqueue(PCB* process,PCB** tail){if((*tail)!=NULL){(*tail)->processlink=process;(*tail)=process;}else{printf("队列未初始化!");}}PCB* getq(PCB* head,PCB** tail){PCB* p;p=head->processlink;if(p!=NULL){head->processlink=p->processlink;p->processlink=NULL;if(head->processlink==NULL)(*tail)=head;}elsereturn NULL;return p;}bool processproc(){int i,f,num;char ch;PCB*p=NULL;PCB** p1=NULL;printf("\n请输入希望产生的进程个数?");scanf("%d",&num);getchar();//if(num>=100){//printf("您怎么要产生这么多进程! Demands Denied!");//return false;//}for(i=0;i<num;i++){printf("\n请输入您要产生的进程:输入1为生产者进程:输入2为消费者进程\n");scanf("%d",&f);getchar();p=(PCB*)malloc(sizeof(PCB));if(!p){printf("内存分配失败");return false;}p->flag=f;processnum++;p->numlabel=processnum;p->state='w';p->processlink=NULL;if(p->flag==1){printf("您要产生的进程是生产者，它是第%d个进程。
《操作系统概念》第七版中的实验项目：生产者消费者问题。
本程序中，main()函数需要三个参数：主线程休眠时间；生产者线程数；消费者线程数。
各线程的休眠等待时间是随机的。
程序代码：#include<stdio.h>#include<stdlib.h>#include<time.h>#include<windows.h>#define BUFFER_SIZE 5typedef int buffer_item;struct v{int i;};buffer_item buffer[BUFFER_SIZE+1];buffer_item front=0,rear=0;HANDLE mutex,empty,full;int insert_item(buffer_item item){/*insert item into bufferreturn 0 if successful,otherwisereturn -1 indicating an error condition*/if((rear+1)%(BUFFER_SIZE+1)==front)return 1;buffer[rear]=item;rear=(rear+1)%(BUFFER_SIZE+1);return 0;}int remove_item(buffer_item *item){/*remove an object from bufferplacing it in itemreturn 0 if successful,otherwisereutrn -1 indication an error condition */if(front == rear)return 1;*item=buffer[front];front=(front+1) % (BUFFER_SIZE+1);return 0;}DWORD WINAPI producer(PVOID Param){int rand1;struct v data=*(struct v *)Param;srand((unsigned)time(0));while (1){Sleep(rand()%101*10);WaitForSingleObject(empty,INFINITE);WaitForSingleObject(mutex,INFINITE);rand1 =rand();printf("producer has producerd %d By %d\n",rand1,data.i);if(insert_item(rand1))printf("insert data error!\n");ReleaseMutex(mutex);ReleaseSemaphore(full,1,NULL);}}DWORD WINAPI consumer(PVOID Param){int rand1;struct v data=*(struct v *)Param;srand((unsigned)time(0));while (1){Sleep(rand()%101*10);WaitForSingleObject(full,INFINITE);WaitForSingleObject(mutex,INFINITE);if(remove_item(&rand1))printf("remove data error! \n");elseprintf("consumer consumed %d By %d \n",rand1,data.i);ReleaseMutex(mutex);ReleaseSemaphore(empty,1,NULL);}}int main(int argc,char *argv[]){/*Get command line arguments argv[1])(the number of producer threads),argv[2](the number of consumer threads),argv[3](sleep time)*//*Initialize buffer*/int sleeptime,pnum,snum;int *ThreadIdP,*ThreadIdS,i;struct v *countp,*counts;HANDLE *ThreadHandleP,*ThreadHandleS;sleeptime=atoi(argv[1]);pnum=atoi(argv[2]);snum=atoi(argv[3]);/*srand(time(NULL));sleeptime=9000;pnum=3;snum=3;*/ThreadHandleP=(HANDLE * )malloc(pnum * sizeof(HANDLE));ThreadHandleS=(HANDLE * )malloc(snum * sizeof(HANDLE));ThreadIdP=(int * )malloc(pnum * sizeof(int));ThreadIdS=(int * )malloc(pnum * sizeof(int));mutex=CreateMutex(NULL,FALSE,NULL);empty=CreateSemaphore(NULL,BUFFER_SIZE,BUFFER_SIZE,NULL);full=CreateSemaphore(NULL,0,BUFFER_SIZE+1,NULL);/*Create producer thread(s)*/countp=(struct v *)malloc((pnum+1)*sizeof(struct v));counts=(struct v *)malloc((snum+1)*sizeof(struct v));for(i=0;i<pnum;i++){countp[i+1].i=i+1;ThreadHandleP[i]=CreateThread(NULL,0,producer,&countp[i+1],0,&ThreadIdP[i]);}/*Create consumer thread(s)*/for(i=0;i<snum;i++){counts[i+1].i=i+1;ThreadHandleS[i]=CreateThread(NULL,0,consumer,&counts[i+1],0,&ThreadIdS[i]);}/*Sleep*/Sleep(sleeptime);/*Exit*/return 0;}#include"stdafx.h"#include<stdio.h>#include<stdlib.h>#include<time.h>#include<windows.h>#define BUFFER_SIZE 5typedef int buffer_item;struct v{int i;};buffer_item buffer[BUFFER_SIZE+1];buffer_item front=0,rear=0;HANDLE mutex,empty,full;int insert_item(buffer_item item){/*insert item into bufferreturn 0 if successful,otherwisereturn -1 indicating an error condition*/if((rear+1)%(BUFFER_SIZE+1)==front)return 1;buffer[rear]=item;rear=(rear+1)%(BUFFER_SIZE+1);return 0;}int remove_item(buffer_item *item){/*remove an object from bufferplacing it in itemreturn 0 if successful,otherwisereutrn -1 indication an error condition */ if(front == rear)return 1;*item=buffer[front];front=(front+1) % (BUFFER_SIZE+1);return 0;}DWORD WINAPI producer(PVOID Param){int rand1;struct v data=*(struct v *)Param;srand((unsigned)time(0));while (1){Sleep(rand()%101*10);WaitForSingleObject(empty,INFINITE);WaitForSingleObject(mutex,INFINITE);rand1 =rand();printf("producer has producerd %d By %d\n",rand1,data.i);if(insert_item(rand1))printf("insert data error!\n");ReleaseMutex(mutex);ReleaseSemaphore(full,1,NULL);}}DWORD WINAPI consumer(PVOID Param){int rand1;struct v data=*(struct v *)Param;srand((unsigned)time(0));while (1){Sleep(rand()%101*10);WaitForSingleObject(full,INFINITE);WaitForSingleObject(mutex,INFINITE);if(remove_item(&rand1))printf("remove data error! \n");elseprintf("consumer consumed %d By %d \n",rand1,data.i);ReleaseMutex(mutex);ReleaseSemaphore(empty,1,NULL);}}int main(int argc,char *argv[]){/*Get command line arguments argv[1])(the number of producer threads),argv[2](the number of consumer threads),argv[3](sleep time)*//*Initialize buffer*/int sleeptime,pnum,snum;DWORD *ThreadIdP,*ThreadIdS,i;struct v *countp,*counts;HANDLE *ThreadHandleP,*ThreadHandleS;/*sleeptime=atoi(argv[1]);pnum=atoi(argv[2]);snum=atoi(argv[3]);*///srand(time(NULL));sleeptime=9000;pnum=3;snum=3;ThreadHandleP=(HANDLE * )malloc(pnum * sizeof(HANDLE));ThreadHandleS=(HANDLE * )malloc(snum * sizeof(HANDLE));ThreadIdP=(DWORD * )malloc(pnum * sizeof(DWORD));ThreadIdS=(DWORD * )malloc(pnum * sizeof(DWORD));mutex=CreateMutex(NULL,FALSE,NULL);empty=CreateSemaphore(NULL,BUFFER_SIZE,BUFFER_SIZE,NULL);full=CreateSemaphore(NULL,0,BUFFER_SIZE+1,NULL);/*Create producer thread(s)*/countp=(struct v *)malloc((pnum+1)*sizeof(struct v));counts=(struct v *)malloc((snum+1)*sizeof(struct v));for(i=0;i<pnum;i++){countp[i+1].i=i+1;ThreadHandleP[i]=CreateThread(NULL,0,producer,&countp[i+1],0,&ThreadIdP[i]);}/*Create consumer thread(s)*/for(i=0;i<snum;i++){counts[i+1].i=i+1;ThreadHandleS[i]=CreateThread(NULL,0,consumer,&counts[i+1],0,&ThreadIdS[i]);}/*Sleep*/Sleep(sleeptime);/*Exit*/return 0;}。
