下载文档原格式
操作系统实验三：生产者——消费者问题一、基本信息xxx 711103xx 2012年4月29日二、实验目的通过实验，掌握Windows和Linux环境下互斥锁和信号量的实现方法，加深对临界区问题和进程同步机制的理解，同时巩固利用Windows API和Pthread API进行多线程编程的方法。
三、实验内容1. 在Windows操作系统上，利用Win32 API提供的信号量机制，编写应用程序实现生产者——消费者问题。
2. 在Linux操作系统上，利用Pthread API提供的信号量机制，编写应用程序实现生产者——消费者问题。
3. 两种环境下，生产者和消费者均作为独立线程，并通过empty、full、mutex 三个信号量实现对缓冲进行插入与删除。
4. 通过打印缓冲区中的内容至屏幕，来验证应用程序的正确性。
四、实验步骤1. 创建3个信号量：Mutex、Full、Empty2. 主程序创建10个生产者线程和10个消费者线程，之后休眠一段时间3. 生产者线程中，休息一段2s后，生产一个0~10的随机数放入缓冲区里。
利用信号量Mutex产生对缓冲区使用的互斥功能，利用Empty和Full信号量来对缓冲区进行增加项4. 消费者线程中，休息4s时间后，消费一个缓冲区的数据。
利用信号量Mutex产生对缓冲区使用的互斥功能，利用Empty和Full信号量来对缓冲区进行增加项5. 主程序执行一段时间后，结束整个程序五、主要数据结构及其说明产品数量最大值const int MAX_SIZE = 10;缓冲区：int buffer[BUFFER_SIZE];int front; int rear; bool full;三个互斥信号量：HANDLE Mutex; HANDLE Full; HANDLE Empty;有关操作：用WaitForSingleSignal函数可以获得一个Mutex的所有权，类似于P 操作，而ReleaseMutex函数可以释放一个Mutex的所有权，类似于V 操作。
#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++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) 生产者——消费者问题。
假定有一个生产者和一个消费者，生产者每次生产一件产品，并把生产的产品存入共享缓冲器以供消费者取走使用。
计算机与信息学院《操作系统与编译原理联合课程设计报告》专题：操作系统部分学生姓名：学号：专业班级：指导教师：2014 年 7 月一、设计目标多进程/线程编程：生产者-消费者问题。
设置两类进程/线程，一类为生产者，一类为消费者；建立缓冲区的数据结构；随机启动生产者或消费者；显示缓冲区状况；随着进程/线程每次操作缓冲区，更新显示。
二、设计思路1.开发平台：Visual C++6.02.设计思路：若干个生产者和若干个消费者共享一个有界缓冲区，生产者生产产品，消费者消费产品。
消费者进程与生产者进程随机切换。
生产者将产品生产出来后，存放到缓冲区中的空闲位置并将此缓冲区的标识置为满，若此时无空缓冲区，则进行等待。
消费者将标识为满的缓冲区中的产品取出，进行消费并将该缓冲区的标志位置为空，若此时无满的缓冲区，则进行等待。
由于消费者与生产者共享缓冲区资源，且缓冲区资源属于互斥资源，所以生产者和消费者需要按照一定的规则访问缓冲区，访问规则如下：（1）当一个消费者访问缓冲区时其他消费者不允许访问缓冲区，同样的，当一个生产者访问缓冲区时其他生产者也不能访问缓冲区。
（2）当消费者访问缓冲区资源时生产者不能访问，反之，当生产者访问缓冲区资源时消费者不能访问。
（3）当缓冲区中无产品时，消费者不能访问；当缓冲区已满时，生产者不能访问缓冲区。
生产者与消费者问题伪代码如下：VAR mutex, empty, full: semaphore := 1, n, 0 ;in,out: integer := 0, 0 ;Buffer: array [0..n-1] of item ;ParbeginProducer:beginrepeatproduce an item in nextp;wait(empty);wait(mutex);Buffer(in) := nextp;in := (in + 1) mod n;signal(mutex);signal(full);until falseendConsumer:beginrepeatwait(full);wait(mutex);nextc = Buffer(out);out := (out + 1) mod n;signal(mutex);signal(empty);consume the item nextc;until falseendParend程序框架如下图所示：本程序在具体实现方面与MFC结合，将生产者-消费者问题的具体过程动态展示了出来。
《生产者---消费者问题源代码》#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");/*换行*/}。
《操作系统》课程设计题目：“生产者-消费者”问题学院：信息工程学院专业：计算机科学与技术班级：计科1302*名：***指导老师：***2016年1月 15日目录一、课程设计目标 (2)二、课题内容 (2)1．实验目的 (2)2、实验环境 (2)3、实验要求 (2)三、设计思路 (3)1.信号量的设置 (3)2.系统结构 (4)3.程序流程图 (5)4.P V操作代码 (6)四、源代码 (7)五、运行与测试 (10)六、心得体会 (12)一、课程设计目标学习System V的进程间通信机制，使用信号量和共享内存实现经典进程同步问题“生产者-消费者”问题。
具体要求：1.创建信号量集，实现同步互斥信号量。
2.创建共享内存，模拟存放产品的公共缓冲池。
3.创建并发进程，实现进程对共享缓冲池的并发操作。
二、课题内容1．实验目的（1）掌握基本的同步互斥算法，理解生产者和消费者同步的问题模型。
（2）了解linux中多线程的并发执行机制，线程间的同步和互斥。
2、实验环境：C/C++语言编译器3、实验要求（1）创建生产者和消费者线程在linux环境下，创建一个控制台进程，在此进程中创建n个线程来模拟生产者或者消费者。
这些线程的信息由本程序定义的“测试用例文件”中予以指定。
（2）生产和消费的规则在按照上述要求创建线程进行相应的读写操作时，还需要符合以下要求：①共享缓冲区存在空闲空间时，生产者即可使用共享缓冲区。
②从上边的测试数据文件例子可以看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。
此时，只有当所有的消费需求都被满足以后，该产品所在的共享缓冲区才可以被释放，并作为空闲空间允许新的生产者使用。
③每个消费者线程的各个消费需求之间存在先后顺序。
例上述测试用例文件包含一行信息“5 C 3 l 2 4”，可知这代表一个消费者线程，该线程请求消费1，2，4号生产者线程生产的产品。
而这种消费是有严格顺序的，消费1号线程产品的请求得到满足后才能继续往下请求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++)<>。
枣庄学院信息科学与工程学院课程设计任务书题目：生产者-消费者问题的实现姓名：学号：专业：计算机科学与技术课程：操作系统指导教师：刘彩霞职称：讲师完成时间：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。
