操作系统课程设计生产者消费者
操作系统课程设计 生产者与消费者
燕山大学课程设计说明书课程设计名称：操作系统OS题目：多道程序缓冲区协调操作班级：开发小组名称：课题负责人：课题组成员：姓名学号班级自评成绩课题开发日期：一、概述利用MFC类库编写一个可实现多道程序缓冲区协调操作的面向对象的程序。
1.1基本功能演示生产者消费者程序，多线程并发执行的过程；可以控制生产者消费者的个数及生产者生产的速度和消费者的速度，进度条中显示Buffer 中数据的个数，有五个按钮，分别为：开始、继续，暂停、结束、退出,点击开始按钮，程序开始执行，点击暂停按钮，所有线程暂停执行，点击继续按钮，线程继续执行，结束按钮使得所有线程结束执行，点击退出按钮，退出系统，统计按钮按下时显示此时的Buffer1，buffer2的生产者生产的次数和Buffer3的消费者消费的次数，及Move的次数，和开始时间及结束时间。
1.2开发计划10号查阅参考资料，了解整体的框架结构； 11号完成整体模块的构思及设计； 12号完成程序具体的编写任务并调试代码； 13号整理总结并书写报告； 14号验收。
1.3人员分工1.4环境、工具和开发方法本程序在XP系统下，采用的开发语言是C++，它是一种使用非常广泛的面向对象的计算机编程语言。
它支持过程化程序设计、数据抽象、面向对象程序设计、制作图标等多种程序设计风格。
在Visual C++ 6.0编程环境中，利用MFC类库编写C++风格的应用程序，基于MFC类库的应用程序可以快速建立起应用程序，并且类库为我们提供了大量的封装类。
二、需求分析用户需要看到看到并发程序的运行过程，以及能对过程进行控制，可以设计几个按钮控制开始，暂停、结束等功能，并可以让用户自定义生产者消费者数量及生产者消费者线程并发执行的速度，并能以用户能够明白的形式表示出来，可以设计一个进度条显示各个Buffer中的物品数量，并用数字显示出来，看的就清楚了，设置一个统计按钮，当用户点击按钮时，就可以获取当前各个线程的情况，有几个线程在执行，Buffer1的线程个数，Buffer2的线程个数及从开始到结束所用的时间，从而了解线程运行的情况。
操作系统_生产者和消费者
《操作系统》课程设计生产者和消费者的问题学院：计算机学院学生姓名：屈杨学号：5409216018专业：计算机科学技术其中实验数据是：3附件：原程序代码#include<windows.h>#include<fstream.h>#include<stdio.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; //是P还是Cdouble delay; //线程延迟int thread_request[MAX_THREAD_NUM]; //线程请求队列int n_request; //请求个数};//全局变量的定义//临界区对象的声明,用于管理缓冲区的互斥访问；CRITICAL_SECTION PC_Critical[MAX_BUFFER_NUM];int Buffer_Critical[MAX_BUFFER_NUM]; //缓冲区声明，用于存放产品；HANDLE h_Thread[MAX_THREAD_NUM]; //用于存储每个线程句柄的数组；ThreadInfo Thread_Info[MAX_THREAD_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 FindProducePositon();int FindBufferPosition(int);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++)Thread_Info[j].thread_request[k] = -1;Thread_Info[j].n_request = 0;}//初始化临界区；for(i =0;i< MAX_BUFFER_NUM;i++)InitializeCriticalSection(&PC_Critical[i]);//打开输入文件，按照规定的格式提取线程等信息；inFile.open("test.txt");//从文件中获得实际的缓冲区的数目；inFile >> n_Buffer_or_Critical;inFile.get();printf("输入文件是:\n");//回显获得的缓冲区的数目信息；printf("%d \n",(int) n_Buffer_or_Critical);//提取每个线程的信息到相应数据结构中；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<Temp_request;k++)printf(" %d ", Thread_Info[j].thread_request[k]);cout<<endl;}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");//下面这个循环用线程的ID号来为相应生产线程的产品读写时所//使用的同步信号量命名；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_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<n_Thread;i++)for(int j=0;j<Thread_Info[i].n_request;j++)if(Thread_Info[i].thread_request[j] == req)return TRUE;return FALSE;}//找出当前可以进行产品生产的空缓冲区位置；int FindProducePosition(){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 FindBufferPosition(int ProPos){int TempPos;for (int i =0 ;i<n_Buffer_or_Critical;i++)if(Buffer_Critical[i]==ProPos){TempPos = i;break;}return TempPos;}//生产者进程void Produce(void *p){//局部变量声明；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);//确认有空缓冲区可供生产，同时将空位置数empty减1；用于生产者和消费者的同步；wait_for_semaphore = WaitForSingleObject(empty_semaphore,-1);//互斥访问下一个可用于生产的空临界区，实现写写互斥；wait_for_mutex = WaitForSingleObject(h_mutex,-1);int ProducePos = FindProducePosition();ReleaseMutex(h_mutex);//生产者在获得自己的空位置并做上标记后，以下的写操作在生产者之间可以并发；//核心生产步骤中，程序将生产者的ID作为产品编号放入，方便消费者识别;printf("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_Critical[ProducePos]);//使生产者写的缓冲区可以被多个消费者使用，实现读写同步；ReleaseSemaphore(h_Semaphore[m_serial],n_Thread,NULL);}//消费者进程void Consume(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;i<m_requestNum;i++)m_thread_request[i] = ((ThreadInfo*)(p))->thread_request[i];Sleep(m_delay);//循环进行所需产品的消费for(i =0;i<m_requestNum;i++){//请求消费下一个产品printf("Consumer %2d request to consume %2d product\n",m_serial,m_thread_request[i]);//如果对应生产者没有生产，则等待；如果生产了,允许的消费者数目-1；实现了读写同步；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 consume %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]);printf(" position[ %2d ]:%3d \n" ,BufferPos,Buffer_Critical[BufferPos]);ReleaseSemaphore(empty_semaphore,1,NULL);}else{printf("Consumer %2d finish consuming product %2d\n ",m_serial,m_thread_request[i]);}//离开临界区LeaveCriticalSection(&PC_Critical[BufferPos]);}}。
操作系统课程设计——生产者消费者问题
计算机与信息学院《操作系统与编译原理联合课程设计报告》专题：操作系统部分学生姓名：学号：专业班级：指导教师：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结合，将生产者-消费者问题的具体过程动态展示了出来。
操作系统课程设计生产者-消费者问题附代码
枣庄学院信息科学与工程学院课程设计任务书题目：生产者-消费者问题的实现姓名：学号：专业：计算机科学与技术课程：操作系统指导教师：刘彩霞职称：讲师完成时间：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。
生产者消费者问题操作系统课程设计
目录1 绪论 (1)1.1 实现的功能 (1)1.2 P V 操作 (1)2 生产者——消费者问题。
(2)2.1 要求 (2)2.2 生产者和消费者两个进程的程序 (2)2.3进程控制块PCB。
(3)2.4处理器的模拟。
(3)2.5程序设计 (3)3设计步骤 (4)3.1课程分析 (5)3.1.2 流程图 (5)3.1.3 测试程序 (7)3.1.4测试结果分析 (12)5 结论 (12)参考文献 (13)1 绪论生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。
模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
1.1 实现的功能生产者-消费者问题是一个经典的进程同步问题，有m个生产者和n个消费者，它们共享可存放k件产品的缓冲区。
生产者进程生产物品，然后将物品放置在一个空缓冲区中，供消费者进程消费。
消费者进程从缓冲区中获得物品，然后释放缓冲区。
当生产者进程生产物品时，如果没有空缓冲区可用，那么生产者进程必须等待消费者线程释放出一个空缓冲区。
当消费者进程消费物品时，如果没有满的缓冲区，那么消费者进程将被阻塞，直到新的物品被生产出来。
1.2 P V 操作(1) PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：P操作原语P (s)：将信号量s减去1，若结果小于0，则执行原语的进程被置成等待信号量s的状态。
操作系统课程设计生产者消费者
生产者消费者问题 （Producer-consumer problem） ， 也称有限缓冲问题 （Bounded-buffer problem），是一个多线程同步问题的经典案例。 该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”— —在实际运行时会发生的问题。 生产者的主要作用是生成一定量的数据放到缓冲区中， 然后 重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者 不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。 要解决该问题，就必须让生产者在缓冲区满时休眠（或者放弃数据），等到下次消费者 消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让 消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常采 用进程间通信的方法解决该问题，常用的方法有信号灯法等。如果解决方法不够完善，则容 易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能 被推广到多个生产者和消费者的情形。
5
pthread_mutex_lock(&lock); while (q->num == 0) { pthread_cond_wait(&empty, &lock); } sem_wait(&product_number); q->front = (q->front + 1) % NUM; char c = q->productc[q->front]; q->productc[q->front] = ' '; q->num--; printf("消费者 1 显示内容： %c\n", c); printf("产品数量：%d\n", q->num); sem_post(&blank_number); if (q->num == NUM - 1) { pthread_cond_signal(&full); } pthread_mutex_unlock(&lock); sleep(rand() % 2); } } void *consumer2(void *arg) { struct P_Queue *q; q = (struct P_Queue *) arg; while (1) { pthread_mutex_lock(&lock); while (q->num == 0) { pthread_cond_wait(&empty, &lock); } sem_wait(&product_number); q->front = (q->front + 1) % NUM; char c = q->productc[q->front]; char d = 0; if(c>=65 && c<=90) { d = c+32;} else { d = c-32;} q->productc[q->front] = ' '; q->num--; printf("消费者 2 更改大小写：%c---%c\n", c,d); printf("产品数量：%d\n", q->num); sem_post(&blank_number); if (q->num == NUM - 1) { pthread_cond_signal(&full); }
生产者消费者问题操作系统课程设计
目录1 绪论 (3)1.1 实现的功能 (3)1.2 P V 操作 (3)2 生产者——消费者问题。
(4)2.1 要求 (4)2.2 生产者和消费者两个进程的程序 (4)2.3进程控制块PCB。
(5)2.4处理器的模拟。
(5)2.5程序设计 (6)3设计步骤 (7)3.1课程分析 (7)3.1.2 流程图 (7)3.1.3 测试程序 (9)3.1.4测试结果分析 (14)5 结论 (15)参考文献 (16)1 绪论生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。
模拟实现用同步机构避免发生进程执行时可能出现的与时间有关的错误。
进程是程序在一个数据集合上运行的过程，进程是并发执行的，也即系统中的多个进程轮流地占用处理器运行。
我们把若干个进程都能进行访问和修改的那些变量称为公共变量。
由于进程是并发地执行的，所以，如果对进程访问公共变量不加限制，那么就会产生“与时间有关”的错误，即进程执行后所得到的结果与访问公共变量的时间有关。
为了防止这类错误，系统必须要用同步机构来控制进程对公共变量的访问。
一般说，同步机构是由若干条原语——同步原语——所组成。
本实习要求学生模拟PV操作同步机构的实现，模拟进程的并发执行，了解进程并发执行时同步机构的作用。
1.1 实现的功能生产者-消费者问题是一个经典的进程同步问题，有m个生产者和n个消费者，它们共享可存放k件产品的缓冲区。
生产者进程生产物品，然后将物品放置在一个空缓冲区中，供消费者进程消费。
消费者进程从缓冲区中获得物品，然后释放缓冲区。
当生产者进程生产物品时，如果没有空缓冲区可用，那么生产者进程必须等待消费者线程释放出一个空缓冲区。
当消费者进程消费物品时，如果没有满的缓冲区，那么消费者进程将被阻塞，直到新的物品被生产出来。
1.2 P V 操作(1) PV操作同步机构，由P操作原语和V操作原语组成，它们的定义如下：P操作原语P (s)：将信号量s减去1，若结果小于0，则执行原语的进程被置成等待信号量s的状态。
操作系统课程设计“生产者-消费者”问题
《操作系统》课程设计题目：“生产者-消费者”问题学院：信息工程学院专业：计算机科学与技术班级：计科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号生产者线程的产品。
现代操作系统课程设计报告 生产者与消费问题
进程同步模拟设计——生产者和消费者问题第一章课设任务本课程设计的任务在于，通过编写一个具体的有关操作系统进程同步互斥的经典问题，加强对操作系统实现进程间同步与互斥的机制的理解。
同时培养提出问题、发现知识、使用工具、解决问题的能力。
具体地，我们要编制出一个程序，利用PV原语以及进程创建、同步、互斥、销毁等相关的系统调用来模拟“生产者—消费者”问题。
第二章背景介绍2.1 “生产者—消费者”问题(the producer-consumer problem)生产者-消费者（producer-consumer）问题，也称作有界缓冲区（bounded-buffer）问题，两个进程共享一个公共的固定大小的缓冲区。
其中一个是生产者，用于将消息放入缓冲区；另外一个是消费者，用于从缓冲区中取出消息。
问题出现在当缓冲区已经满了，而此时生产者还想向其中放入一个新的数据项的情形，其解决方法是让生产者此时进行休眠，等待消费者从缓冲区中取走了一个或者多个数据后再去唤醒它。
同样地，当缓冲区已经空了，而消费者还想去取消息，此时也可以让消费者进行休眠，等待生产者放入一个或者多个数据时再唤醒它。
问题分析：该问题涉及到操作系统进程管理当中的两个重要概念——同步和互斥。
同步，表现在生产者和消费者需要协同工作，步调不能拉开太大（由缓冲区大小n决定，n越大，缓冲空间越大，步调可以拉得越开；n=1时，必须是生产一个，消费一个，生产者和消费者就完全同步了）。
当步调差距超过极限时，走在前面的当前进程（生产者）调用P 原语时由于资源耗尽，被阻塞；步调靠后的继续向前推进。
由此实现同步。
互斥，表现在生产者与消费者、生产者与生产者、消费者与消费者任何两个成员之间必须互斥地使用缓冲区。
当有一个成员进入缓冲区存/取产品时，其他成员将被关在门外排队等候（被阻塞）；当完毕时，通知队首成员进入。
由操作系统理论可知，我们需要三个信号量，分别命名full, empty, mutex，来分别代表消费者的可用资源数、生产者的可用资源数、缓冲区是否可用。
计算机操作系统课程设计报告《生产者---消费者问题》
计算机操作系统课程设计报告《生产者---消费者问题》《计算机操作系统》课程设计题目：生产者---消费者问题专业：软件工程年级：2010级小组成员： A B指导教师：时间：地点：2012年5 月摘要生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。
该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。
生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。
与此同时，消费者也在缓冲区消耗这些数据。
该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。
生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
目录1. 概述 (4)2. 课程设计任务及要求 (4)2.1 设计任务 (4)2.2 设计要求 (4)2.3 分工日程表 (4)3. 算法及数据结构 (5)3.1算法的总体思想 (5)3.2 生产者模块 (5)3.3 消费者模块 (7)4. 程序设计与实现 (8)4.1 程序流程图 (8)4.2 程序代码 (9)4.3 实验结果 (14)5. 结论 (17)6. 收获、体会和建议 (17)6.1收获......................................... 错误！未定义书签。
7. 参考文献 (18)1. 概述本课题设计是完成了“操作系统原理”课程进行的一次全面的综合训练，通过这次课程设计，充分检验学生对课程的掌握程度和熟练情况，让学生更好的掌握操作系统的原理及其实现方法，加深对课程的基础理论和算法的理解，加强学生的动手能力。
操作系统课程设计生产者消费者
操作系统课程设计说明书题目: 生产者消费者同步算法院系：专业班级：姓名：指导教师：目录1 概述 (3)1.1目的 (3)1.2主要完成的任务 (3)1.3使用的开发工具 (3)1.4解决的主要问题 (4)2 使用的基本概念和原理 (4)2.1多道程序 (4)2.2进程 (4)2.3线程 (5)2.4同步 (5)2.5互斥 (5)3 总体设计 (6)3.1 (6)3.2 (6)3.3 .............................................................................................................. 错误!未定义书签。
3.4 .............................................................................................................. 错误!未定义书签。
4 详细设计 (6)4.1信号量类Semaphore: (6)4.2生产者类Producer (7)4.3消费者Consumer类 (7)4.4Buffer类 (7)4.5Mover 类 (7)4.6主类MainFrame (8)5 编码设计 (8)5.1编译环境，注意问题 (8)5.2源代码 (8)5.3测试 (17)5．4使用说明书 (18)6 总结 (18)7参考文献 (19)生产者消费者同步算法1 概述1.1目的用户需要看到并发程序的运行过程，以及能对过程进行控制，可以设计几个按钮控制开始，暂停、结束等功能，并可以让用户自定义生产者消费者数量及生产者消费者线程并发执行的速度，并能以用户能够明白的形式表示出来，可以设计一个进度条显示各个Buffer中的物品数量，并用数字显示出来，看的就清楚了，设置一个统计按钮，当用户点击按钮时，就可以获取当前各个线程的情况，有几个线程在执行，缓冲区线程个数及从开始到结束所用的时间，从而了解线程运行的情况。
操作系统生产者与消费者课程设计
操作系统课程设计课题名称：Windows OS平台下的生产者和消费者问题班级：软件学号：姓名：指导教师：成绩：目录一、课程设计目的 (1)二、课程任务描述 (1)三、技术方案 (1)1. 算法分析 (1)2. 技术机制 (4)3. 库函数介绍 (5)4. 运行环境 (7)四、详细设计 (7)1．程序框架 (8)2．数据结构 (10)3. 流程图 (10)五、运行与测试 (11)六、总结及改进意见 (11)七、附录 (11)一、课程设计目的1.理解生产者消费者模型，掌握基本的同步、互斥算法。
2.理解操作系统中进程间通信机制IPC3.掌握以生产者/消费者模型为依据，在Windows环境下创建一个控制台进程，实现进程(线程)的同步与互斥。
4.掌握和使用共享主存实现进程间通信机制。
二、课程任务描述设计一个C+程序，该程序通过线程并发机制创建两类线程，分别是消费者线程和生产者线程，并运用IPC机制，在Windows平台下，使用信号量和共享内存实现“生产者-消费者”问题。
具体要求：1.使用IPC机制创建信号集，实现”生产者-消费者“问题中的同步与互斥。
2.使用IPC机制创建共享内存，模拟存放产品的公共缓冲区。
3.以生产者/消费者模型为依据，在Windows环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。
三、技术方案1.算法分析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);elseh_Thread[i]=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)(Consume),& (Thread_Info[i]),0,NULL);}2）生产者进程void Produce(void *p){//局部变量声明；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);//确认有空缓冲区可供生产，同时将空位置数empty减1；用于生产者和消费者的同步；wait_for_semaphore = WaitForSingleObject(empty_semaphore,-1);//互斥访问下一个可用于生产的空临界区，实现写写互斥；wait_for_mutex = WaitForSingleObject(h_mutex,-1);int ProducePos = FindProducePosition();ReleaseMutex(h_mutex);//生产者在获得自己的空位置并做上标记后，以下的写操作在生产者之间可以并发；//核心生产步骤中，程序将生产者的ID作为产品编号放入，方便消费者识别;printf("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_Critical[ProducePos]);//使生产者写的缓冲区可以被多个消费者使用，实现读写同步；ReleaseSemaphore(h_Semaphore[m_serial],n_Thread,NULL);}3）消费者进程void Consume(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;i<m_requestNum;i++)m_thread_request[i] = ((ThreadInfo*)(p))->thread_request[i];Sleep(m_delay);//循环进行所需产品的消费for(i =0;i<m_requestNum;i++){//请求消费下一个产品printf("Consumer %2d request to consume %2d product\n",m_serial,m_thread_request[i]);//如果对应生产者没有生产，则等待；如果生产了,允许的消费者数目-1；实现了读写同步；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 consume %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]);printf(" position[ %2d ]:%3d \n" ,BufferPos,Buffer_Critical[BufferPos]);ReleaseSemaphore(empty_semaphore,1,NULL);}else{printf("Consumer %2d finish consuming product %2d\n ",m_serial,m_thread_request[i]);}//离开临界区LeaveCriticalSection(&PC_Critical[BufferPos]);}}2.技术机制有一个有限缓冲区和多个线程：生产者和消费者。
生产者与消费者的问题操作系统课程设计范本
生产者与消费者的问题操作系统课程设计闽江学院计算机系网络操作系统课程设计设计内容：进程机制与并发程序设计——linux下生产者与消费者的问题实现目录：一、设计内容 (3)二、设计思想 (4)三、系统结构 (5)四、PV操作代码 (5)五、C++程序代码 (6)六、运行结果截图 (9)七、参考文献 (11)八、实验总结 (11)一、设计内容进程机制与并发程序设计————linux下生产者与消费者的问题实现1．实验目的（1）掌握基本的同步互斥算法，理解生产者和消费者同步的问题模型。
（2）了解linux中多线程的并发执行机制，线程间的同步和互斥。
2、实验环境：C/C++语言编译器3、实验要求（1）创立生产者和消费者线程在linux环境下，创立一个控制台进程，在此进程中创立n个线程来模拟生产者或者消费者。
这些线程的信息由本程序定义的“测试用例文件”中予以指定。
该文件的格式和含义如下：31 P 32 P 43 C4 14 P 25 C 3 1 2 4第一行说明程序中设置几个临界区，其余每行分别描述了一个生产者或者消费者线程的信息。
每一行的各字段间用Tab键隔开。
不论是消费者还是生产者，都有一个对应的线程号，即每一行开始字段那个整数。
第二个字段用字母P或者C区分是生产者还是消费者。
第三个字段表示在进入相应线程后，在进行生产和消费动作前的休眠时间，以秒计时；这样做的目的是能够经过调整这一列参数，控制开始进行生产和消费动作的时间。
如果是代表生产者，则该行只有三个字段。
如果代表消费者，则该行后边还有若干字段，代表要求消费的产品所对应的生产者的线程号。
因此务必确认这些对应的线程号存在而且该线程代表一个生产者。
（2）生产和消费的规则在按照上述要求创立线程进行相应的读写操作时，还需要符合以下要求：①共享缓冲区存在空闲空间时，生产者即可使用共享缓冲区。
②从上边的测试数据文件例子能够看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。
四川大学操作系统课程设计第三次实验报告生产者和消费者
实验报告（学生打印后提交）实验名称: 生产者和消费者问题实验时间: 2023年 5 月 5日●实验人员:●实验目的：掌握基本的同步互斥算法, 理解生产者和消费者模型。
●了解Windows 2023/XP中多线程的并发执行机制, 线程间的同步和互斥。
●学习使用Windows 2023/XP中基本的同步对象, 掌握相应的API●实验环境: WindowsXP ＋ VC++6.0●运用Windows SDK提供的系统接口（API, 应用程序接口）完毕程序的功能。
API是操作系统提供的用来进行应用程序设计的系统功能接口。
使用API, 需要包含对API函数进行说明的SDK头文献, 最常见的就是windows.h实验环节:1.读懂源程序.2.编辑修改源程.......................................实验陈述:1.基础知识:本实验用到几个API函数：CreateThread CreateMutex, WaitForSingleObject, ReleaseMutexCreateSemaphore, WaitForSingleObject, ReleaseSemaphore, ReleaseMutex, nitializeCriticalSection, EnterCriticalSection, LeaveCriticalSection。
这些函数的作用：CreateThread, 功能：创建一个线程, 该线程在调用进程的地址空间中执行。
CreateMutex,功能：产生一个命名的或者匿名的互斥量对象。
WaitForSingleObject（相应p操作）锁上互斥锁, ReleaseMutex（相应v操作）打开互斥锁.。
CreateSemaphore, 创建一个命名的或者匿名的信号量对象。
信号量可以看作是在互斥量上的一个扩展。
WaitForSingleObject, 功能：使程序处在等待状态, 直到信号量（或互斥量）hHandle出现或者超过规定的等待最长时间, 信号量出现指信号量大于或等于1, 互斥量出现指打开互斥锁。
生产者消费者问题 操作系统课程设计
生产者消费者问题操作系统课程设计本文介绍了操作系统课程设计中的生产者消费者问题。
生产者消费者问题是一种经典的同步问题，涉及到多个线程或进程的协作与同步。
在该问题中，有一定数量的生产者和消费者，它们共享一个有限的缓冲区。
生产者负责往缓冲区中添加数据，而消费者则负责从缓冲区中取出数据。
缓冲区的大小是有限的，当缓冲区已满时，生产者就需要等待，直到有消费者来取出数据；当缓冲区为空时，消费者也需要等待，直到有生产者添加数据为止。
为了解决生产者消费者问题，操作系统课程设计中通常采用信号量机制来进行同步和互斥。
生产者和消费者需要共享两个信号量：一个用来表示空闲缓冲区的数量，另一个用来表示有数据的缓冲区的数量。
当生产者添加数据时，需要使用信号量将空闲缓冲区的数量减1，然后将数据添加到缓冲区；当消费者取出数据时，需要使用信号量将有数据的缓冲区的数量减1，然后将数据从缓冲区中取出。
当缓冲区已满或为空时，线程需要进行等待，直到有信号量被释放。
操作系统课程设计中，生产者消费者问题可以作为实验来进行实践。
通过编写程序实现生产者消费者问题，可以加深对操作系统中同步和互斥的理解，同时也可以提高编程能力和解决问题的能力。
- 1 -。
操作系统课程设计生产者消费者
（操作系统课程设计）生产者和消费者学生姓名：学生学号：班级：0311401、02、03、04班制二〇一三年十二月一、课程题目分析这个题目是生产者向消费者提供商品，消费者消耗商品，并且两组人共用同一缓冲区。
生产者提供了商品之后消费者才能去取商品，消费者若不取走商品则当缓冲区用完之后生产者则不能再向缓冲区中添加新的商品。
思考问题：（1）对于生产者进程：每产生一个数据，则需去访问共用缓冲区是否有已满，未满则可以将该数据存入并通知消费者进程，否则不能。
（2）对于消费者进程：每当想去消费（取出数据）时，则需访问缓冲区是否为空，为空则不能消费（取出数据），否则可以取，并通知生产者。
（3）缓冲区是个临界资源，所有的进程对于该空间都是共享的，所以，还有互斥问题存在。
二、课程设计目的通过实验模拟生产者与消费者之间的关系，了解并掌握他们之间的关系及原理。
由此增加对进程同步问题的了解：（1）掌握基本的同步互斥算法，理解生产者与消费者模型（2）了解windows中多线程（多进程）的并发执行机制，线程（进程）间的同步于互斥（3）学习使用windows中基本的同步对象，掌握相应的API。
三、课程设计内容有n个生产者和m个消费者，连接在具有k个单位缓冲区的有界环转缓冲上，故又称有界缓冲问题。
其中Pi 和Cj都是并发进程，只要缓冲区未满，生产者进程Pi 所生产的产品就可投入缓冲区；类似地，只要缓冲区非空，消费者进程Cj就可以从缓冲区取走并消耗产品。
四、开发环境操作系统：Windows系统编写语言：C++语言五、系统分析设计（一）算法原理生产者——消费者问题是典型的进程同步问题，这些进程必须按照一定的生产率和消费率来访问共享缓冲区，用P、V操作解决生产者和消费者共享单缓冲区的问题，可设置两个信号量empty和full，其初值分别为1和0，empty指示能否向缓冲区放入产品，full指示能否从缓冲区取出产品。
为了使其协调工作，必须使用一个信号量mutex（初值为1），以限制生产者和消费者互斥地对缓冲区进行存取，另用两个信号量empty1（初值为缓冲区大小）和full1（初值为0），以保证生产者不向已满的缓冲区中放入产品，消费者不从空缓冲区中取产品。
操作系统课程设计-管程的实现(生产者消费者问题)
操作系统课程设计2、管程的实现（生产者消费者问题）1.设计背景：管程是一种高级抽象数据类型，它支持在它的函数中隐含互斥操作。
结合条件变量和其他一些低级通信原语，管程可以解决许多仅用低级原语不能解决的同步问题。
例如，本实验中利用管程提供一个不会发生死锁的生产者消费者问题就是利用管程的很好的例子。
管程封装了并发进程或线程要互斥执行的函数。
为了让这些并发进程或线程在管程内互斥的执行，管程的实现必须隐含的具有锁或二值信号量。
如果没有条件变量，管程就不会有很有用，条件变量提供了一种对管程内并发协作进程的同步机制。
条件变量代表了管程中一些并发进程或线程可能要等待的条件。
一个条件变量管理着管程内的一个等待队列。
如果管程内某个进程或线程发现其执行条件为假，则该进程或线程就会被条件变量挂入管程内等待该条件的队列。
如果管程内另外的进程或线程满足了这个条件，则它会通过条件变量再次唤醒等待该条件的进程或线程，从而避免了死锁的产生。
所以，一个条件变量C应具有两种操作 C.wait()和C.signal()。
当管程内同时出现唤醒者和被唤醒者时，由于要求管程内的进程或线程必须互斥执行，因此就出现了两种样式的条件变量：Mesa Style(signal-and-continue): 唤醒者进程或线程继续执行，被唤醒者进程或线程等到唤醒者进程或线程阻塞或离开管程后再执行。
Hoare Style(signal-and-wait): 被唤醒者进程或线程立即执行，唤醒者进程或线程阻塞，直道被唤醒者阻塞或离开管程后再执行。
我们实验所做的就是在原来mesa样式的基础上进行Hoare样式的改进;这种样式也是我们实验中需要实现的样式。
2.设计目标验证并分析Nachos中Bridge管程是否能够正确的解决单行桥双向过桥问题。
定义和实现Hoare样式的条件变量Condition_H类利用Hoare样式的条件变量Condition_H,实现Ring类中定义的各个方法,使用Ring管程解决生产者/消费者问题。
操作系统生产者与消费者课程设计
一、课程设计的性质与任务1、生产者-消费者问题是很经典很具有代表性的进程同步问题，计算机中的很多同步问题都可抽象为生产者-消费者问题，通过本实验的练习，希望能加深学生对进程同步问题的认识与理解。
2、熟悉VC的使用，培养和提高学生的分析问题、解决问题的能力。
二、课程设计的内容及其要求1．实验内容以生产者/消费者模型为依据，在Windows 2000环境下创建一个控制台进程，在该进程中创建n个线程模拟生产者和消费者，实现进程(线程)的同步与互斥。
2．实验要求●学习并理解生产者/消费者模型及其同步/互斥规则；●学习了解Windows同步对象及其特性；●熟悉实验环境，掌握相关API的使用方法；●设计程序，实现生产者/消费者进程(线程)的同步与互斥；●提交实验报告。
三、课程设计的时间安排课程设计时间8课时四、课程设计的实验环境本实验是在winxp＋VC6.0环境下实现的，利用Windows SDK编制实例程序。
所以试验需要在windows下安装VC后进行。
VC是一个集成开发环境，其中包含了Windows SDK所有工具和定义；所以安装了VC后就不用特意安装SDK了。
五、正文1、实验程序的结构图（流程图）；开始Wait ProductsWait BufferConsumeProduceWhile consumeWhile produce结束2、数据结构及信号量定义的说明；(1) CreateThread●功能——创建一个在调用进程的地址空间中执行的线程●格式HANDLE CreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes,DWORD dwStackSize,LPTHREAD_START_ROUTINE lpStartAddress,LPVOID lpParamiter,DWORD dwCreationFlags,Lpdword lpThread );●参数说明lpThreadAttributes——指向一个LPSECURITY_ATTRIBUTES(新线程的安全性描述符)。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统课程设计报告题目：生产这消费者问题班级：小组成员：2010年1月8日-2010年1月12日一：概述1.1 基本功能：演示生产者消费者程序，多线程并发执行的过程；可以控制生产者消费者的个数及生产者生产的速度和消费者的速度，进度条中显示Buffer 中数据的个数，有五个按钮，分别为：开始、继续，暂停、结束、退出,点击开始按钮，程序开始执行，点击暂停按钮，所有线程暂停执行，点击继续按钮，线程继续执行，结束按钮使得所有线程结束执行，点击退出按钮，退出系统，统计按钮按下时显示此时的Buffer1，buffer2的生产者生产的次数和Buffer3的消费者消费的次数，及Move的次数，和开始时间及结束时间。
1.2开发计划：第一天：完成整体的规划工作，设计几个类，各个类有什么方法，能完成什么工作，如何设计构造方法第二天：完成操作界面的设计与编码，设计一个美观，易于操作的界面第三天：完成并发设计内核的结构与实现工作第四天：把内核与界面整合在一起，用事件把按钮实现的功能和文本框显示的文字与内核结合起来，基本完成程序设计工作第五天：完成代码的优化工作，添加一些功能，及完成实验报告。
1.3 人员分工蔡春龙负责整体的规划，褚江负责主界面的规划，具体的实现由两人共同完成。
1.4 开发环境工具和方法：开发环境Windows XP操作系统：JDK1.6 JCreater开发工具：Java开发方法：小组共同开发二：需求分析用户需要看到看到并发程序的运行过程，以及能对过程进行控制，可以设计几个按钮控制开始，暂停、结束等功能，并可以让用户自定义生产者消费者数量及生产者消费者线程并发执行的速度，并能以用户能够明白的形式表示出来，可以设计一个进度条显示各个Buffer中的物品数量，并用数字显示出来，看的就清楚了，设置一个统计按钮，当用户点击按钮时，就可以获取当前各个线程的情况，有几个线程在执行，Buffer1的线程个数，Buffer2的线程个数，Buffer3的线程个数及从开始到结束所用的时间，从而了解线程运行的情况。
三：软件设计设计了6个类，分别为:信号量类Semaphore、生产者类Producer、消费者类Consumer、缓冲池类Buffer、转移类Mover、主界面类MainFrame,下面详细介绍各个类的功能。
信号量类Semaphore:信号量类Semaphore把操作系统课本上的P、V操作用Java实现了，使得在别的类中就可以直接使用P、V操作来实现，就大大降低了编写代码的难度。
生产者类Producer有六个成员变量mutex ,full,empty; buf; name;frame;timesOfProducer;信号量mutex实现互斥功能，使得各个线程互斥的进入临界区，buf表示的生产者是哪个缓冲池的生产者（Buffer1还是Buffer2），empty表示缓冲池可用的空间大小，full表示缓冲池中数据的个数，name即为该线程的名字，frame是MainFrame类型的对象，在后面会用到，timeOfProducer表示生产者生产的次数，初值设为0，每执行一次生产，timeOfProducer自动加1，就完成了计数功能。
消费者Consumer类类似生产者类，成员变量不同的是timesOfConsumer,记录生产者生产的次数，实现与生产者的timeOfProducer 类似，都是没执行依次消费，timeOfProducer自动加1；Buffer类可以存放生产者生产的物品，有三个参数number; size ；value;,number标识是Buffer1、Buffer2还是Buffer3，size标识Buffer的最大容量，在此设为10；value标识Buffer某时中的物品数量。
Mover 类实现吧Buffer1或Buffer2中的数据转入Buffer3，当Buffer1或Buffer2不为空时，就把它们中的数据转移到Buffer3中，并设置Buffer3的empty-1,full+1;主类MainFrame做了一个界面，主函数Main也包含在这个类中，界面左边可以设置Buffer1,Buffer2,的生产者个数，Buffer3 的消费者个数，以及Buffer1,Buffer2,Buffer3的生产者消费者速度，中间的文本域显示的是各线程并发执行的信息，下方是控制按钮，可以控制开始，结束，暂停，继续，退出，统计信息，右方设计的是进度条显示的Buffer，Buffer2、Buffer3中物品的个数，用图形化的方式显示出来，看的更清晰。
四：.编码设计信号量类：public class Semaphore {private int semV alue;public Semaphore(int semV alue){this.semV alue=semV alue;}public synchronized void p(){ //实现P操作semV alue--;if(semV alue<0){//没有可用资源try{this.wait(); //等待}catch(InterruptedException e){}}}public synchronized void v(){、、实现V操作semV alue++;if(semV alue<=0){this.notify(); //唤醒等待的线程}}}Buffer类Buffer：public class Buffer{private int number; //编号private int size; // 容量private int value; //数据格式故public Buffer(int number,int size,int value){this.number=number;this.size=size;this.value=value;}public int getV alue() { //获取V alue的值return value;}}生产者类Producer:public class Producer implements Runnable{private Semaphore mutex ,full,empty;//信号量型的变量private Buffer buf;private String name;private MainFrame frame;private static int timesOfProducer; //生产者生产的次数public Producer (MainFrame frame,String name,Semaphore mutex,Semaphore full,Semaphore empty,Buffer buf){this.mutex=mutex;this.full=full;this.empty=empty;this.buf=buf;=name;this.frame=frame;}public void run(){while(true){empty.p();mutex.p();frame.jta.append("Producer "+name+" insert a new product into "+buf.number+"\n");timesOfProducer++; 计数器+1buf.value++;if(buf.number==1){frame.jprogressBar1.setV alue(buf.value);//Buffer1进度条设值frame.jprogressBar1.setString(String.valueOf(buf.value));}else{frame.jprogressBar2.setV alue(buf.value);//Buffer2的进度条设值frame.jprogressBar2.setString(String.valueOf(buf.value));}mutex.v();full.v();try{Thread.sleep(2000);}catch(InterruptedException e){}}//抛出InterruptException异常}public static int getProduceTimes(){return timesOfProducer;}}消费者类Consumer;public class Consumer implements Runnable{private Semaphore mutex,full,empty;private Buffer buf;private String name;private MainFrame frame;private static int timesOfConsumer;public Consumer(MainFrame frame,String name,Semaphore mutex,Semaphore full,Semaphore empty,Buffer buf){this.mutex=mutex;this.full=full;this.empty=empty;this.buf=buf;=name;this.frame=frame;}public void run(){while(true){full.p();mutex.p();frame.jta.append("Consumer "+name+" get a product from "+buf.number+"\n");timesOfConsumer++;buf.value--;//Buffer的数据数减1frame.jprogressBar3.setV alue(buf.value);frame.jprogressBar3.setString(String.valueOf(buf.value));mutex.v();empty.v();try{Thread.sleep(1500);}catch(InterruptedException e){}}}public static int getConsumeTimes(){return timesOfConsumer;}}Move类Mover:public class Mover implements Runnable{private Semaphore mutex1,mutex2,full1,full2,empty1,empty2;private Buffer buf1,buf2;private String name;private MainFrame frame;private static int moveTimes;public Mover(MainFrame frame,String name,Semaphore mutex1,Semaphore mutex2,Semaphore full1,Semaphore full2,Semaphore empty1,Semaphore empty2,Buffer buf1,Buffer buf2){ this.mutex1=mutex1;this.mutex2=mutex2;this.full1=full1;this.full2=full2;this.empty1=empty1;this.empty2=empty2;this.buf1=buf1;this.buf2=buf2;=name;this.frame=frame;}public void run(){while(true){//一直循环full1.p();empty2.p();mutex1.p();mutex2.p();frame.jta.append("Mover "+name+" move a product from Buffer "+buf1.number+" to Buffer "+buf2.number+"\n");moveTimes++;buf1.value--;buf2.value++;if(buf1.number==1){frame.jprogressBar1.setV alue(buf1.value);//设置进度条1的值frame.jprogressBar1.setString(String.valueOf(buf1.value));}else{frame.jprogressBar2.setV alue(buf1.value);//设置进度条2的值frame.jprogressBar2.setString(String.valueOf(buf1.value));}frame.jprogressBar3.setV alue(buf2.value);frame.jprogressBar3.setString(String.valueOf(buf2.value));//设置进度条3的值mutex1.v();mutex2.v();empty1.v();full2.v();}}public static int getMoveTimes(){return moveTimes;//返回移动的次数}}主界面类MainFrame：import java.awt.*;import javax.swing.*;import java.awt.event.*;import javax.swing.event.*;import java.util.*;public class MainFrame extends JFrame implements ActionListener,ChangeListener{JTextField numOfProducer1; //文本域JTextField numOfProducer2;JTextField numOfConsumer;JSlider jSlider1; //滑竿JSlider jSlider2;JSlider jSlider3;int nOP1=0; //Buffer1的生产者的数量int nOP2=0;int nOC=0;int sOP1=0;int sOP2=0;int sOC=0;int i=0;JTextArea jta=new JTextArea(); //建一个文本域JScrollPane jScrollPane=new JScrollPane(); //滚动条JButton jbtSet; //开始//几个控制键JButton jbtStart; //继续JButton jbtStop; //停止JButton jbtEnd; //结束JButton jbtExit; //退出JButton jbtTime; //点下按钮的时间JLabel time; //显示时间的标签JProgressBar jprogressBar1;JProgressBar jprogressBar2;JProgressBar jprogressBar3;static final int MINIMUM=0; //进度条的最小值static final int MAXIMUM=10; //进度条的最大值Buffer buffer1=new Buffer(1,10,0);Buffer buffer2=new Buffer(2,10,0);Buffer buffer3=new Buffer(3,10,0);Semaphore mutex1=new Semaphore(1); //互斥信号量Semaphore mutex2=new Semaphore(1);Semaphore mutex3=new Semaphore(1);Semaphore full1=new Semaphore(0);Semaphore full2=new Semaphore(0);Semaphore full3=new Semaphore(0);Semaphore empty1=new Semaphore(10);Semaphore empty2=new Semaphore(10);Semaphore empty3=new Semaphore(10);Thread[] thread =new Thread[100];Date startTime; //开始时间Date stopTime; //停止时间Thread move1=new Thread(new Mover(this,"mover1",mutex1,mutex3,full1,full3,empty1,empty3,buffer1,buffer 3));Thread move2=new Thread(new Mover(this,"mover2",mutex2,mutex3,full2,full3,empty2,empty3,buffer2,buffer 3));public MainFrame(){numOfProducer1=new JTextField(2); //创建对象numOfProducer2=new JTextField(2);numOfConsumer=new JTextField(2);jbtSet=new JButton("开始");jbtStart=new JButton("继续");jbtStop=new JButton("暂停");jbtEnd=new JButton("结束");jbtExit=new JButton("退出");jbtTime=new JButton("统计次数");time=new JLabel();jbtSet.addActionListener(this);jbtStart.addActionListener(this);jbtStop.addActionListener(this);jbtEnd.addActionListener(this);jbtExit.addActionListener(this);jbtTime.addActionListener(this);numOfProducer1.addActionListener(this);numOfProducer2.addActionListener(this);numOfConsumer.addActionListener(this);jSlider1=new JSlider(JSlider.HORIZONTAL,0,50,25); //第一个参数为水平，第2、3个为最小最大值，最后的为初值jSlider2=new JSlider(JSlider.HORIZONTAL,0,50,30);jSlider3=new JSlider(JSlider.HORIZONTAL,0,50,15);jSlider1.addChangeListener(this);jSlider2.addChangeListener(this);jSlider3.addChangeListener(this);//拖动触发stateChanged事件Container container=this.getContentPane();container.setLayout(new BorderLayout());JPanel panel1=new JPanel();//面板1JPanel panel2=new JPanel();JPanel panel3=new JPanel();panel1.setLayout(new GridLayout(6,2,0,0)); //panel1.add(new JLabel("Buffer1的生产者个数"));panel1.add(numOfProducer1);panel1.add(new JLabel("Buffer2的生产者个数"));panel1.add(numOfProducer2);panel1.add(new JLabel("Buffer3的消费者个数"));panel1.add(numOfConsumer);panel1.add(new JLabel("Buffer1的生产者速度"));panel1.add(jSlider1);panel1.add(new JLabel("Buffer2的生产者速度"));panel1.add(jSlider2);panel1.add(new JLabel("Buffer3的消费者速度"));panel1.add(jSlider3);container.add(panel1,BorderLayout.WEST);//放到主界面的北面panel2.setLayout(new FlowLayout());panel2.add(jbtSet);panel2.add(jbtStart);panel2.add(jbtStop);panel2.add(jbtEnd);panel2.add(jbtExit);panel2.add(jbtTime);panel2.add(time);container.add(panel2,BorderLayout.SOUTH);panel3.setLayout(new GridLayout(6,1));jprogressBar1=new JProgressBar ();jprogressBar2=new JProgressBar ();jprogressBar3=new JProgressBar ();jprogressBar1.setMinimum(MINIMUM);jprogressBar1.setMaximum(MAXIMUM);jprogressBar1.setStringPainted(true);jprogressBar2.setMinimum(MINIMUM);jprogressBar2.setMaximum(MAXIMUM);jprogressBar2.setStringPainted(true);jprogressBar3.setMinimum(MINIMUM);jprogressBar3.setMaximum(MAXIMUM);jprogressBar3.setStringPainted(true);panel3.add(new JLabel(" buffer1的容量"));panel3.add(jprogressBar1);panel3.add(new JLabel(" buffer2的容量"));panel3.add(jprogressBar2);panel3.add(new JLabel(" buffer3的容量"));panel3.add(jprogressBar3);container.add(panel3,BorderLayout.EAST);container.add(jScrollPane,BorderLayout.CENTER);jScrollPane.getViewport().add(jta,null);//加入水平和竖直滚动条}public void actionPerformed(ActionEvent e){if(e.getSource()==numOfProducer1){nOP1=Integer.parseInt(numOfProducer1.getText());ThreadGroup p1=new ThreadGroup("Buffer1生产进程组");for(i=0;i<nOP1;i++){//设置Buffer1的生产者数量thread[i]=new Thread(p1,new Producer(this,"Pro1"+(i+1),mutex1,full1,empty1,buffer1));}}if(e.getSource()==numOfProducer2){nOP2=Integer.parseInt(numOfProducer2.getText());ThreadGroup p2=new ThreadGroup("Buffer2生产进程组");for(i=nOP1;i<nOP1+nOP2;i++){thread[i]=new Thread(p2,new Producer(this,"Pro2"+(i-nOP1+1),mutex2,full2,empty2,buffer2));}}if(e.getSource()==numOfConsumer){nOC=Integer.parseInt(numOfConsumer.getText());ThreadGroup c=new ThreadGroup("Buffer3消费者进程组"); //建立线程组for(i=nOP1+nOP2;i<nOP1+nOP2+nOC;i++){thread[i]=new Thread(c,new Consumer(this,"Con"+(i-nOP1-nOP2+1),mutex3,full3,empty3,buffer3));}}if(e.getSource()==jbtExit){dispose();//退出体统System.exit(0);time.setText(new Date().toString());}//显示时间if(e.getSource()==jbtSet){move1.start();move2.start();for(i=0;i<nOP1+nOP2+nOC;i++){thread[i].start();//所有线程开始执行time.setText(new Date().toString());startTime=new Date();}}if(e.getSource()==jbtStart){move1.resume() //唤醒休眠的线程;move2.resume();for(i=0;i<nOP1+nOP2+nOC;i++){thread[i].resume();time.setText(new Date().toString());}}if(e.getSource()==jbtEnd){//停止所有线程的运行move1.stop();move2.stop();for(i=0;i<nOP1+nOP2+nOC;i++){thread[i].stop();time.setText(new Date().toString());}time.setText(new Date().toString());}if(e.getSource()==jbtTime){//显示生产者1、2和消费者的生产消费的次数及点击开始按钮和结束按钮的时间String s="生产者生产了"+Producer.getProduceTimes()+"次"+'\n'+"消费者消费了"+Consumer.getConsumeTimes()+"次" +'\n'+" move进行了"+Mover.getMoveTimes()+"次"+'\n'+"开始时间"+startTime.toString()+'\n'+"结束时间"+stopTime.toString();JOptionPane.showMessageDialog(null,s);}if(e.getSource()==jbtStop){move1.suspend();move2.suspend();for(i=0;i<nOP1+nOP2+nOC;i++){thread[i].suspend();}time.setText(new Date().toString());stopTime=new Date();}}public void stateChanged(ChangeEvent e){//处理滑竿事件if((JSlider)e.getSource()==jSlider1){sOP1=jSlider1.getV alue();}if((JSlider)e.getSource()==jSlider2){sOP2=jSlider2.getV alue();}if((JSlider)e.getSource()==jSlider3){sOC=jSlider3.getV alue();}}public static void main(String[] args){//主函数MainFrame myframe=new MainFrame();myframe.setTitle("操作系统课程设计");myframe.setV isible(true);myframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);myframe.setSize(900,300);Dimension //设置主界居中显示screenSize=Toolkit.getDefaultToolkit().getScreenSize();int screenWidth=screenSize.width;int screenHeight=screenSize.height;int x=(screenWidth-myframe.getWidth())/2;int y=(screenHeight-myframe.getHeight())/2;myframe.setLocation(x,y);}}五.测试开始时出现了很多问题，最后都一一解决了，这是最后调试成功的主界面：右面方不开、放在下面显示：运行结果：统计信息：六.简要说明书使用说明书：点击”生产者消费者.jar”即可计入主界面，在主界面上进行各个操作。