操作系统实验 生产者与消费者问题代码
编程模拟生产者和消费者问题(附代码程序)
实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟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) 生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
C语言编程模拟生产者和消费者问题(附代码程序)
实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟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) 生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
计算机操作系统课程设计源代码《生产者---消费者问题源代码》
《生产者---消费者问题源代码》#include<stdio.h>#include<stdlib.h>#include<string.h>#include<pthread.h>#include<semaphore.h>#include<sys/types.h>#include<errno.h>#include<unistd.h>#include<signal.h>#include<time.h>#define NUM_THREADS_P5/*定义数据为生产者*/#define NUM_THREADS_C5/*定义数据为消费者*/#define MAX_BUFFER20/*定义数据为缓存区*/#define RUN_TIME20/*定义运行时间*/int buffer[MAX_BUFFER];/*定义最大缓存区*/int produce_pointer=0,consume_pointer=0;/*定义指针*/sem_t producer_semaphore,consumer_semaphore,buffer_mutex;/*定义信号量，互斥*/pthread_t threads_p[NUM_THREADS_P];/*声明生产者线程*/pthread_t threads_c[NUM_THREADS_C];/*声明消费者线程*/FILE*fd;void*producer_thread(void*tid);/*声明生产者线程*/void*consumer_thread(void*tid);/*声明消费者线程*/void showbuf();/*声明showbuf方法*/void handler(){int i;/*定义i*/for(i=0;i<NUM_THREADS_P;i++)pthread_cancel(threads_p[i]);/*for循环，如果i<NUM_THREADS_P,则pthread_cancel(threads_p[i]);并且i++*/ for(i=0;i<NUM_THREADS_C;i++)pthread_cancel(threads_c[i]);/*for循环，如果i<NUM_THREADS_C,则pthread_cancel(threads_c[i]);并且i++*/}int main(){int i;/*定义i*/signal(SIGALRM,handler);/*定义信号量*/fd=fopen("output.txt","w");/*打开一个文件用来保存结果*/sem_init(&producer_semaphore,0,MAX_BUFFER);/*放一个值给信号灯*/sem_init(&consumer_semaphore,0,0);sem_init(&buffer_mutex,0,1);for(i=0;i<MAX_BUFFER;i++)buffer[i]=0;/*引发缓冲*//*创建线程*/for(i=0;i<NUM_THREADS_P;i++)pthread_create(&threads_p[i],NULL,(void*)producer_thread,(void*)(i+1)); /*创建线程*/for(i=0;i<NUM_THREADS_C;i++)pthread_create(&threads_c[i],NULL,(void*)consumer_thread,(void*)(i+1));alarm(RUN_TIME);for(i=0;i<NUM_THREADS_P;i++)pthread_join(threads_p[i],NULL);/*等待线程退出*/for(i=0;i<NUM_THREADS_C;i++)pthread_join(threads_c[i],NULL);/*等待线程退出*/sem_destroy(&producer_semaphore);/*清除信号灯*/sem_destroy(&consumer_semaphore);/*清除信号灯*/sem_destroy(&buffer_mutex);/*清除缓存区*/fclose(fd);/*关闭文件*/return0;}void*producer_thread(void*tid){pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);/*设置状态，PTHREAD_CANCEL_ENABLE是正常处理cancel信号*/ while(1){sem_wait(&producer_semaphore);/*等待，需要生存*/srand((int)time(NULL)*(int)tid);sleep(rand()%2+1);/*一个或两个需要生产*/while((produce_pointer+1)%20==consume_pointer);/*指针位置*/sem_wait(&buffer_mutex);/*缓存区*/buffer[produce_pointer]=rand()%20+1;/*指针位置*/produce_pointer=(produce_pointer+1)%20;/*指针位置*//*判断*/if(produce_pointer==0){printf("生产者:%d指针指向:%2d生产产品号:%2d\n",(int)tid,19,buffer[19]);/*输出生产者，指针，缓存区*/fprintf(fd,"生产者:%d指针指向:%2d生产产品号:%2d\n",(int)tid,19,buffer[19]);/*输出生产者，指针，缓存区*/}else{printf("生产者:%d指针指向:%2d生产产品号:%2d\n",(int)tid,produce_pointer-1,buffer[produce_pointer-1]);/*输出生产者，指针，缓存区*/fprintf(fd,"生产者:%d指针指向:%2d生产产品号:%2d\n",(int)tid,produce_pointer-1,buffer[produce_pointer-1]);/*输出生产者，指针，缓存区*/}showbuf();sem_post(&buffer_mutex);sem_post(&consumer_semaphore);/*通知消费者缓冲区不是空的*/srand((int)time(NULL)*(int)tid);sleep(rand()%5+1);/*等待几秒钟,然后继续生产*/}return((void*)0);}void*consumer_thread(void*tid){/*可以被其他线程使用*/pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);/*设置状态，PTHREAD_CANCEL_ENABLE是忽略cancel信号*/while(1){sem_wait(&consumer_semaphore);/*通知消费者消费*/srand((int)time(NULL)*(int)tid);sleep(rand()%2+1);/*一个或两个来消费*/sem_wait(&buffer_mutex);printf("消费者:%d指针指向:%2d消费产品号:%2d\n",(int)tid,consume_pointer,buffer[consume_pointer]);/*输出消费者，消费者指针，缓存区*/fprintf(fd,"消费者:%d指针指向:%2d消费产品号:%2d\n",(int)tid,consume_pointer,buffer[consume_pointer]);/*输出消费者，消费者指针，缓存区*/buffer[consume_pointer]=0;/*消费者指针指向0*/consume_pointer=(consume_pointer+1)%20;showbuf();sem_post(&buffer_mutex);sem_post(&producer_semaphore);/*通知生产者缓冲区不是空的*/srand((int)time(NULL)*(int)tid);sleep(rand()%5+1);/*等待几秒钟,然后继续消费*/}return((void*)0);}/*查看缓冲区内容*/void showbuf(){int i;/*定义i*/printf("buffer:");/*输出缓存区*/fprintf(fd,"buffer:");/*输出缓存区*/for(i=0;i<MAX_BUFFER;i++){printf("%2d",buffer[i]);/*输出缓存区i*/fprintf(fd,"%2d",buffer[i]);/*输出缓存区i*/ }printf("\n\n");/*换行*/fprintf(fd,"\n\n");/*换行*/}。
操作系统生产者消费者问题代码
#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<<"发出消费请求。
操作系统_生产者与消费者问题的实现
//shmctl(shmid,IPC_RMID,&buf);
//del_sem(semid);
return 0;
}
/*生产者写5次后退出*/
void producer(key_t keyFull, key_t keyEmpty)
empty Write P1 : 2
empty Write P2 : 4
in = 0
Write : 5
full Write V1 : 0
full Write V2 : 0
full Read P2 : 0
out = 0
Read : 5
empty Read V1 : 4
empty Read V2 : 5
Write : 7
full Write V1 : 0
full Write V2 : 0
full Read P2 : 0
out = 2
Read : 7
empty Read V1 : 4
empty Read V2 : 5
Read Finish
p(empty); /*是否有空缓冲区，有则占有，无则被挂起，是原子操作*/
printf("empty Write P2 : %d\n", semctl(empty, 0, GETVAL, 0));
value_write++;
in = in++;
pData[in] = value_write;
in = in % 5;
printf("full Write V2 : %d\n", semctl(full, 0, GETVAL, 0));
操作系统实验报告经典生产者—消费者问题
操作系统实验报告经典生产者—消费者问题实验二经典的生产者—消费者问题一、目的实现对经典的生产者—消费者问题的模拟，以便更好的理解经典进程同步问题。
二、实验内容及要求编制生产者—消费者算法，模拟一个生产者、一个消费者，共享一个缓冲池的情形。
1、实现对经典的生产者—消费者问题的模拟，以便更好的理解此经典进程同步问题。
生产者－消费者问题是典型的PV 操作问题，假设系统中有一个比较大的缓冲池，生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中，而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。
缓冲池被占用时，任何进程都不能访问。
2、每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。
在这种情况下，生产者消费者进程同步，因为只有通过互通消息才知道是否能存入产品或者取走产品。
他们之间也存在互斥，即生产者消费者必须互斥访问缓冲池，即不能有两个以上的进程同时进行。
三、生产者和消费者原理分析在同一个进程地址空间内执行两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放一个空缓冲区。
当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻挡，直到新的物品被生产出来。
四、生产者与消费者功能描述：生产者功能描述：在同一个进程地址空间内执行两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
消费者功能描述：消费者线程从缓冲区获得物品，然后释放缓冲区，当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。
五、实验环境操作系统环境：Windows 系统。
编程语言：C#。
操作系统课程设计生产者-消费者问题附代码
枣庄学院信息科学与工程学院课程设计任务书题目：生产者-消费者问题的实现姓名：学号：专业：计算机科学与技术课程：操作系统指导教师：刘彩霞职称：讲师完成时间：2012年5月----2012 年6月枣庄学院信息科学与工程学院制课程设计任务书及成绩评定目录第1章引言 (1)1.1 设计背景 (1)1.2 问题分类 (1)1.3 解决方案 (1)第2章设计思路及原理 (2)第3章程序详细设计 (3)3.1程序模块设计 (3)3.2程序代码结构 (5)第4章实验结果 (7)第5章实验总结 (8)附录：实验代码 (9)第1章引言1.1 设计背景生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra 提出，用以演示他提出的信号量机制。
在同一个进程地址空间内执行的两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。
1.2 问题分类根据缓冲区的个数、大小以及生产者消费者的个数可以分为以下几类：1.单缓冲区(适合单或多生产消费者);2.环行多缓冲区（或无穷缓冲区）单生产消费者;3.环行多缓冲区多生产消费者;1.3 解决方案1.用进程通信(信箱通信)的方法解决;2.进程消息缓冲通信;3.进程信箱通信;第2章设计思路及原理设计了两个主要函数：生产者函数、消费者函数；设计了三个信号量：full信号量，判断缓冲区是否有值，初值为0；empty信号量，判断缓冲区是否有空缓冲区，初值为缓冲区数；mutex信号量作为互斥信号量，用于互斥的访问缓冲区。
生产者函数通过执行P操作信号量empty减1，判断缓冲区是否有空。
有空则互斥的访问缓冲区并放入数据，然后释放缓冲区，执行V操作，信号量full 加1。
操作系统实验（生产者消费者问题java实现）
操作系统实验（生产者消费者问题java实现）一实验目的1 深刻理解进程同步的概念。
2 掌握经典同步问题，生产者——消费者问题。
二实验设备PC机三实验内容在Java开发平台模拟经典进程同步问题，生产者——消费者问题。
四程序的主要代码import java.awt.*;import javax.swing.*;import java.awt.event.*;public class PAC extends JFrame{protected JButton producer1,producer2,producer3,consumer1,consumer2,consumer3; protected JTextField blank1,blank2,blank3,blank4,blank5;int[] array = new int[5];public PAC(){JPanel p1 = new JPanel(new FlowLayout(FlowLayout.CENTER,2,2));p1.add(producer1 = new JButton("生产者1"));p1.add(producer2 = new JButton("生产者2"));p1.add(producer3 = new JButton("生产者3"));JPanel p2 = new JPanel(new FlowLayout(FlowLayout.CENTER,2,2));p2.add(new JLabel("缓冲区"));p2.add(blank1 = new JTextField(5));p2.add(blank2 = new JTextField(5));JPanel p3 = new JPanel(new FlowLayout(FlowLayout.CENTER,2,2));p3.add(consumer1 = new JButton("消费者1"));p3.add(consumer2 = new JButton("消费者2"));p3.add(consumer3 = new JButton("消费者3"));JPanel p4 = new JPanel(new GridLayout(4,1,2,2));p4.add(new JLabel("阻塞队列"));p4.add(blank3 = new JTextField(5));p4.add(blank4 = new JTextField(5));p4.add(blank5 = new JTextField(5));JPanel p5 = new JPanel(new GridLayout(3,1,10,50));p5.add(p1);p5.add(p2);p5.add(p3);JPanel p6 = new JPanel(new BorderLayout(3,3));p6.add(p4,BorderLayout.EAST);p6.add(p5,BorderLayout.CENTER);setLayout(new FlowLayout(FlowLayout.CENTER,10,20)); this.getContentPane().add(p6);producer1.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){wh(1);}});producer2.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){wh(2);}});producer3.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){wh(3);}});consumer1.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){whh(1);}});consumer2.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){whh(2);}});consumer3.addActionListener(new ActionListener(){public void actionPerformed(ActionEvent e){whh(3);}});}public void wh(int n){for(int i = 0;i < 5; i++){if(array[i] == 0 && array[2] < 0){switch(-array[2]){case 1:consumer1.setEnabled(true);break;case 2:consumer2.setEnabled(true);break;case 3:consumer3.setEnabled(true);break;}array[2] = array[3];array[3] = array[4];array[4] = 0;break;}else if(array[i] == 0 ){if(array[1] == 0){array[i] = n;break;}if(array[1] != 0){array[i] = n;switch(n){case 1:producer1.setEnabled(false);break;case 2:producer2.setEnabled(false);break;case 3:producer3.setEnabled(false);break;}break;}}}blank1.setText(" " + array[0]);blank2.setText(" " + array[1]);blank3.setText(" " + array[2]);blank4.setText(" " + array[3]);blank5.setText(" " + array[4]);}public void whh(int n){if (array[0] != 0){switch(array[2]){case 1:producer1.setEnabled(true);break;case 2:producer2.setEnabled(true);break;case 3:producer3.setEnabled(true);break;}for (int k = 0; k < 4; k++)array[k] = array[k + 1];array[4] = 0;}else{for (int k = 2; k < 5; k++){if (array[k] == 0){array[k] = -n;switch(n){case 1:consumer1.setEnabled(false);break;case 2:consumer2.setEnabled(false);break;case 3:consumer3.setEnabled(false);break;}break;}}}blank1.setText(" " + array[0]);blank2.setText(" " + array[1]);blank3.setText(" " + array[2]);blank4.setText(" " + array[3]);blank5.setText(" " + array[4]);}public static void main(String[] args){PAC frame = new PAC();frame.pack();frame.setTitle("生产者与消费者问题实验");frame.setSize(500,300);frame.setLocationRelativeTo(null);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setVisible(true);}}/**生产者1、2、3分别生产数字1、2、3；消费者1、2、3的消费请求进入阻塞队列后分别对应-1、-2、-3。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
for (int i=0;i<m_request[i] = ((ThreadInfo*)(p))->thread_request[i]);
sleep(m_delay);
for(i=0;i<m_requestNUM;i++){
{
for (int i=0;i<n_Thread;i++)
for (int j=0;j<Thread_Info[i].n_request;j++)
if(Thread_Info[i].thread_request[j] == req)
return TRUE;
}
int FindProducePosition()
cout<<end1;
}
printf("\n\n");
empty_semaphore=CreateSemaphore(NULL,n_Buffer_or_Critical,n_Buffer_or_Critical,"semaphore_for_empty");
h_mutex = CreateMutex(NULL,FALSE,"mutex_for_update");
((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]);
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)
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;
wait_for_semaphore=WaitForSingleObject(enpty_semaphore,-1);
wait_for_mutex = WaitForSingleObject(h_mutex,-1);
int producepos = FindProducePosition();
ReleaseMutex(h_mutex);
int main(void)
{
DWORD wait_for_all;
ifstream inFile;
for (int i=0;i<MAX_BUFFER_NUM;i++)
Buffer_Critical[i] = -1;
for (int j=0;j<MAX_THREAD_NUM;j++)
for (int k=0;k<MAX_THREAD_NUM;k++)
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++];
#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
}
LeaveCriticalSection(&PC_Critical[Bufferpos]);
}
}
{
int EmptyPosition;
for(int i=0;i<n_Buffer_or_Critical;i++)
if(Buffer_Critical[i] == -1){
EmptyPosition = i;
Buffer_Critical[i] ==ቤተ መጻሕፍቲ ባይዱ-2;
break;
}
return EmptyPosition;
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;
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);
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;
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);
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<Temp_request;k++)
printf("%d ",Thread_Info[j].thread_request[k]);
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());
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;
HANDLE h_Semaphore[MAX_THREAD_NUM];
void Produce (void *p);
void Consume (void *p);
bool IfInOtherRequest(int);
int FindProducePosition();
int FindBufferPosition(int);
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;