操作系统生产者消费者问题C语言

合集下载

C语言调用库函数实现生产者消费者问题

C语言调用库函数实现生产者消费者问题

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<<"发出消费请求。

C语言编程模拟生产者和消费者问题(附代码程序)

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) 生产者——消费者问题。

假定有一个生产者和一个消费者,生产者每次生产一件产品,并把生产的产品存入共享缓冲器以供消费者取走使用。

C语言编程模拟生产者和消费者问题 附代码程序

C语言编程模拟生产者和消费者问题 附代码程序

实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。

进程是程序在一个数据集合上运行的过程,进程是并发执行的,也即系统中的多个进程轮流地占用处理器运行。

我们把若干个进程都能进行访问和修改的那些变量称为公共变量。

由于进程是并发地执行的,所以,如果对进程访问公共变量不加限制,那么就会产生“与时间有关”的错误,即进程执行后所得到的结果与访问公共变量的时间有关。

为了防止这类错误,系统必须要用同步机构来控制进程对公共变量的访问。

一般说,同步机构是由若干条原语——同步原语——所组成。

本实习要求学生模拟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 实现)

操作系统之生产者消费者问题(C  实现)

/*----------------------把新生产的产品放入缓冲区开------------------------*/
//把新生产的产品放入缓冲区 void Append() { std::cerr<<"把生产的产品送入缓冲区";
g_buffer[in]=ProductID; in=(in+1)%SIZE_OF_BUFFER; std::cerr<<std::endl; std::cout<<"缓冲区 产品 生产者/消费者"<<std::endl;
{
if(g_buffer[i]<10) std::cout<<" "; else std::cout<<" "; std::cout<<" <-- 生产者";//输出生产者的指针位置 } if(i==out) { if(g_buffer[i]<10) std::cout<<" "; else std::cout<<" "; std::cout<<" <-- 消费者";//输出消费者的指针位置 } std::cout<<std::endl; } } /*----------------------把新生产的产品放入缓冲区结------------------------*/
(算法流程图、编程及程序注释等)
主要的方法:
4、运行结果分析 1、运行示例 在 c++中运行源程序 ,程序主界面截图.按回车及申请资源和缓冲区进行 p 操作 和申请互斥(生产者和消费者都是 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++)<>。

C语言编程模拟生产者和消费者问题(附代码程序)

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) 生产者——消费者问题。

假定有一个生产者和一个消费者,生产者每次生产一件产品,并把生产的产品存入共享缓冲器以供消费者取走使用。

C语言编程模拟生产者和消费者问题

C语言编程模拟生产者和消费者问题

实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。

进程是程序在一个数据集合上运行的过程,进程是并发执行的,也即系统中的多个进程轮流地占用处理器运行。

我们把若干个进程都能进行访问和修改的那些变量称为公共变量。

由于进程是并发地执行的,所以,如果对进程访问公共变量不加限制,那么就会产生“与时间有关”的错误,即进程执行后所得到的结果与访问公共变量的时间有关。

为了防止这类错误,系统必须要用同步机构来控制进程对公共变量的访问。

一般说,同步机构是由若干条原语——同步原语——所组成。

本实习要求学生模拟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语言编程模拟生产者和消费者问题(附代码程序)

C语言编程模拟生产者和消费者问题(附代码程序)

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个进程。

操作系统之进程(生产者---消费者)实验报告

操作系统之进程(生产者---消费者)实验报告

操作系统实验报告——生产者和消费者问题姓名:学号:班级:一、实验内容1、模拟操作系统中进程同步和互斥;2、实现生产者和消费者问题的算法实现;二、实验目的1、熟悉临界资源、信号量及PV操作的定义与物理意义;2、了解进程通信的方法;3、掌握进程互斥与进程同步的相关知识;4、掌握用信号量机制解决进程之间的同步与互斥问题;5、实现生产者-消费者问题,深刻理解进程同步问题;三、实验题目在Windows操作系统下用C语言实现经典同步问题:生产者—消费者,具体要求如下:(1)一个大小为10的缓冲区,初始状态为空。

(2)2个生产者,随机等待一段时间,往缓冲区中添加数据,若缓冲区已满,等待消费者取走数据之后再添加,重复10次。

页脚内容1(3)2个消费者,随机等待一段时间,从缓冲区中读取数据,若缓冲区为空,等待生产者添加数据之后再读取,重复10次。

四、思想本实验的主要目的是模拟操作系统中进程同步和互斥。

在系统进程并发执行异步推进的过程中,由于资源共享和进程间合作而造成进程间相互制约。

进程间的相互制约有两种不同的方式。

(1)间接制约。

这是由于多个进程共享同一资源(如CPU、共享输入/输出设备)而引起的,即共享资源的多个进程因系统协调使用资源而相互制约。

(2)直接制约。

只是由于进程合作中各个进程为完成同一任务而造成的,即并发进程各自的执行结果互为对方的执行条件,从而限制各个进程的执行速度。

生产者和消费者是经典的进程同步问题,在这个问题中,生产者不断的向缓冲区中写入数据,而消费者则从缓冲区中读取数据。

生产者进程和消费者对缓冲区的操作是互斥,即当前只能有一个进程对这个缓冲区进行操作,生产者进入操作缓冲区之前,先要看缓冲区是否已满,如果缓冲区已满,则它必须等待消费者进程将数据取出才能写入数据,同样的,消费者进程从缓冲区读取数据之前,也要判断缓冲区是否为空,如果为空,则必须等待生产者进程写入数据才能读取数据。

在本实验中,进程之间要进行通信来操作同一缓冲区。

C语言编程模拟生产者和消费者问题

C语言编程模拟生产者和消费者问题

实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。

进程是程序在一个数据集合上运行的过程,进程是并发执行的,也即系统中的多个进程轮流地占用处理器运行。

我们把若干个进程都能进行访问和修改的那些变量称为公共变量。

由于进程是并发地执行的,所以,如果对进程访问公共变量不加限制,那么就会产生“与时间有关” 的错误,即进程执行后所得到的结果与访问公共变量的时间有关。

为了防止这类错误,系统必须要用同步机构来控制进程对公共变量的访问。

一般说,同步机构是由若干条原语——同步原语——所组成。

本实习要求学生模拟PV 操作同步机构的实现,模拟进程的并发执行,了解进程并发执行时同步机构的作用。

二、实验环境Windows操作系统和Visual C++专业版或企业版三、实验步骤模拟PV 操作同步机构,且用PV 操作解决生产者——消费者问题。

[提示]:⑴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语言编程模拟生产者和消费者问题(附代码程序)(2)

C语言编程模拟生产者和消费者问题(附代码程序)(2)

实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。

进程是程序在一个数据集合上运行的过程,进程是并发执行的,也即系统中的多个进程轮流地占用处理器运行。

我们把若干个进程都能进行访问和修改的那些变量称为公共变量。

由于进程是并发地执行的,所以,如果对进程访问公共变量不加限制,那么就会产生“与时间有关”的错误,即进程执行后所得到的结果与访问公共变量的时间有关。

为了防止这类错误,系统必须要用同步机构来控制进程对公共变量的访问。

一般说,同步机构是由若干条原语一一同步原语一一所组成。

本实习要求学生模拟PV 操作同步机构的实现,模拟进程的并发执行,了解进程并发执行时同步机构的作用。

二、实验环境Windows操作系统和VisualC++6.0 专业版或企业版三、实验步骤模拟PV操作同步机构,且用PV操作解决生产者一一消费者问题。

[提示]:(1) 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<Othe nW(s)en d{p}procedurev(vars:semaphore);egin s:=s+1;ifs -0thenR(s)en d{v}其中W(s)表示将调用过程的进程置为等待信号量s的状态;R(s)表示释放一个等待信号量s的进程。

在系统初始化时应把semaphore定义为某个类型,为简单起见,在模拟实习中可把上述的semaphore 直接改成integer 。

(2) 生产者一一消费者问题。

假定有一个生产者和一个消费者,生产者每次生产一件产品,并把生产的产品存入共享缓冲器以供消费者取走使用。

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

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

实验一生产者和消费者问题1、程序流程图2、源代码#include <windows.h>#include <iostream>const unsigned short SIZE_OF_BUFFER = 10;unsigned short ProductID = 0;unsigned short ConsumeID = 0;unsigned short in = 0;unsigned short out = 0;int g_buffer[SIZE_OF_BUFFER];bool g_continue = true;HANDLE g_hMutex;HANDLE g_hFullSemaphore;HANDLE g_hEmptySemaphore;DWORD WINAPI Producer(LPVOID);DWORD WINAPI Consumer(LPVOID);int main(){ g_hMutex = CreateMutex(NULL,FALSE,NULL);g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL);g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);const unsigned short PRODUCERS_COUNT = 3;const unsigned short CONSUMERS_COUNT = 1;const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;HANDLE hThreads[PRODUCERS_COUNT];DWORD producerID[CONSUMERS_COUNT];DWORD consumerID[THREADS_COUNT];for (int i=0;i<PRODUCERS_COUNT;++i){hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);if (hThreads[i]==NULL) return -1;}for ( i=0;i<CONSUMERS_COUNT;++i){hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);if (hThreads[i]==NULL) return -1;}while(g_continue){if(getchar()){ //按回车后终止程序运行g_continue = false;}}return 0;}void Produce(){ std::cerr << "Producing " << ++ProductID << " ... ";std::cerr << "Succeed" << std::endl;}void Append(){ std::cerr << "Appending a product ... ";g_buffer[in] = ProductID;in = (in+1)%SIZE_OF_BUFFER;std::cerr << "Succeed" << std::endl;for (int i=0;i<SIZE_OF_BUFFER;++i){std::cout << i <<": " << g_buffer[i];if (i==in) std::cout << " <-- 生产";if (i==out) std::cout << " <-- 消费";std::cout << std::endl;}}void Take(){ std::cerr << "Taking a product ... ";ConsumeID = g_buffer[out];out = (out+1)%SIZE_OF_BUFFER;std::cerr << "Succeed" << std::endl;for (int i=0;i<SIZE_OF_BUFFER;++i){std::cout << i <<": " << g_buffer[i];if (i==in) std::cout << " <-- 生产";if (i==out) std::cout << " <-- 消费";std::cout << std::endl; }}void Consume(){ std::cerr << "Consuming " << ConsumeID << " ... ";std::cerr << "Succeed" << std::endl;}DWORD WINAPI Producer(LPVOID lpPara){ while(g_continue){WaitForSingleObject(g_hFullSemaphore,INFINITE);WaitForSingleObject(g_hMutex,INFINITE);Produce();Append();Sleep(1500);ReleaseMutex(g_hMutex);ReleaseSemaphore(g_hEmptySemaphore,1,NULL);}return 0;}DWORD WINAPI Consumer(LPVOID lpPara){ while(g_continue){WaitForSingleObject(g_hEmptySemaphore,INFINITE);WaitForSingleObject(g_hMutex,INFINITE);Take();Consume();Sleep(1500);ReleaseMutex(g_hMutex);ReleaseSemaphore(g_hFullSemaphore,1,NULL);}return 0;}3、实验结果3、实验心得通过做生产者消费者问题这个实验,让我更加明确了两者之间的联系和基本的同步互斥算法,了解多线程并发执行机制是怎样的,线程间的同步和互斥又是怎样的,还有缓冲区的在其中作用是什么。

C语言编程模拟生产者和消费者问题(附代码程序)

C语言编程模拟生产者和消费者问题(附代码程序)

实验三编程模拟生‎产者和消费‎者问题一、实验目的和‎要求模拟实现用‎同步机构避‎免发生进程‎执行时可能‎出现的与时‎间有关的错‎误。

进程是程序‎在一个数据‎集合上运行‎的过程,进程是并发‎执行的,也即系统中‎的多个进程‎轮流地占用‎处理器运行‎。

我们把若干‎个进程都能‎进行访问和‎修改的那些‎变量称为公‎共变量。

由于进程是‎并发地执行‎的,所以,如果对进程‎访问公共变‎量不加限制‎,那么就会产‎生“与时间有关‎”的错误,即进程执行‎后所得到的‎结果与访问‎公共变量的‎时间有关。

为了防止这‎类错误,系统必须要‎用同步机构‎来控制进程‎对公共变量‎的访问。

一般说,同步机构是‎由若干条原‎语——同步原语——所组成。

本实习要求‎学生模拟P‎V操作同步‎机构的实现‎,模拟进程的‎并发执行,了解进程并‎发执行时同‎步机构的作‎用。

二、实验环境Windo‎w s操作系‎统和Vis‎u al C++6.0专业版或‎企业版三、实验步骤模拟PV操‎作同步机构‎,且用PV操‎作解决生产‎者——消费者问题‎。

[提示]:(1) PV操作同‎步机构,由P操作原‎语和V操作‎原语组成,它们的定义‎如下:P操作原语‎P (s):将信号量s‎减去1,若结果小于‎0,则执行原语‎的进程被置‎成等待信号‎量s的状态‎。

V操作原语‎V (s):将信号量s‎加1,若结果不大‎于0,则释放一个‎等待信号量‎s的进程。

这两条原语‎是如下的两‎个过程:proce‎d ure p (var s: semap‎h ore);begin‎s: = s-1;if s<0 then W (s)end {p}proce‎d ure v (var s: semap‎h ore);egin s: = s+1;if s 0 then R (s)end {v}其中W(s)表示将调用‎过程的进程‎置为等待信‎号量s的状‎态;R(s)表示释放一‎个等待信号‎量s的进程‎。

C语言编程模拟生产者和消费者问题(附代码程序)电子教案

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) 生产者——消费者问题。

假定有一个生产者和一个消费者,生产者每次生产一件产品,并把生产的产品存入共享缓冲器以供消费者取走使用。

【8A版】C语言编程模拟生产者和消费者问题(附代码程序)

【8A版】C语言编程模拟生产者和消费者问题(附代码程序)

实验三编程模拟生产者和消费者问题一、实验目的和要求模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。

进程是程序在一个数据集合上运行的过程,进程是并发执行的,也即系统中的多个进程轮流地占用处理器运行。

我们把若干个进程都能进行访问和修改的那些变量称为公共变量。

由于进程是并发地执行的,所以,如果对进程访问公共变量不加限制,那么就会产生“与时间有关”的错误,即进程执行后所得到的结果与访问公共变量的时间有关。

为了防止这类错误,系统必须要用同步机构来控制进程对公共变量的访问。

一般说,同步机构是由若干条原语——同步原语——所组成。

本实习要求学生模拟PV操作同步机构的实现,模拟进程的并发执行,了解进程并发执行时同步机构的作用。

二、实验环境Windows操作系统和VisualC++6.0专业版或企业版三、实验步骤模拟PV操作同步机构,且用PV操作解决生产者——消费者问题。

[提示]:(1)PV操作同步机构,由P操作原语和V操作原语组成,它们的定义如下:P操作原语P(s):将信号量s减去1,若结果小于0,则执行原语的进程被置成等待信号量s的状态。

V操作原语V(s):将信号量s加1,若结果不大于0,则释放一个等待信号量s的进程。

这两条原语是如下的两个过程:procedurep(vars:semaphore);begins:=s-1;ifs<0thenW(s)end{p}procedurev(vars:semaphore);egins:=s+1;ifs 0thenR(s)end{v}其中W(s)表示将调用过程的进程置为等待信号量s的状态;R(s)表示释放一个等待信号量s的进程。

在系统初始化时应把semaphore定义为某个类型,为简单起见,在模拟实习中可把上述的semaphore直接改成integer。

(2)生产者——消费者问题。

假定有一个生产者和一个消费者,生产者每次生产一件产品,并把生产的产品存入共享缓冲器以供消费者取走使用。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《操作系统概念》第七版中的实验项目:生产者消费者问题。

本程序中,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;}。

相关文档
最新文档