操作系统实验报告-三大经典问题之生产者与消

操作系统实验三：生产者——消费者问题一、基本信息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 操作。

《操作系统》实验报告生产者和消费者的问题一、实验目的1.掌握基本的同步与互斥的算法，理解基本的生产者与消费者的模型。

2.学习使用Windows 2000/XP中基本的同步对象，掌握相关的API的使用方法。

3.了解Windows 2000/XP中多线程的并发执行机制，线程间的同步和互斥。

二、实验的内容及其要求1.实验内容以生产者/消费者模型为根据，在Windows 2000环境下创建一个控制台进程，在改进程中创建n个线程模拟生产者和消费者，实现进程（线程）的同步与互斥。

2．实验要求①学习并理解生产者/消费者模型及其同步/互斥规则②学习了解Windows同步对象及其特性③熟悉实验环境，掌握相关API的使用方法④设计程序，实现生产者/消费者进程（线程）的同步与互斥⑤提交实验报告三、实验的时间安排1．实验前，先到图书馆或上网百度了解有关生产者/消费者模型的相关知识，建立生产者/消费者模型的基本概念。

2．利用13周、15周、17周的上机时间编写和调试程序代码。

3．利用其他课余时间来分析实验的最终结果并完成相关的实验报告。

四、实验的环境1.硬件条件：普通计算机一台2.软件条件：①操作系统：Windows 2000/XP②开发语言：VC++本实验是在Windows 2000+VC6.0环境下实现的，利用Windows SDK提供的系统接口（API）完成程序的功能。

实验在Windows 下安装VC后进行，因为VC是一个集成开发环境，其中包含了Windows SDK所有工具和定义，所以安装了VC后就不用特意安装SDK了。

实验中所用的API（应用程序接口），是操作系统提供的用来进行应用程序设计的系统功能接口。

要使用这些API，需要包含对这些函数进行说明的SDK头文件，最常见的就是windows.h。

一些特殊的API调用还需要包含其他的头文件。

五、正文1．程序结构图：2.数据结构：（1）用一个整型数组Buffer_Critical来代表缓冲区。

实验报告二实验名称:一、生产者-消费者问题的多线程解决方案二、设计一个执行矩阵乘法的多线程程序日期：2015-10-22 班级：13级计科学号:姓名：一、实验目的1.掌握线程的同步与互斥2.掌握生产者消费者的实现问题3.掌握多线程的编程方法4.掌握矩阵乘法的基本计算原理以及实现二、实验内容1.生产者-消费者问题的多线程解决方案2.设计一个执行矩阵乘法的多线程程序三、项目要求与分析1．请查阅资料，掌握线程创建的相关知识以及矩阵乘法的相关知识，了解java语言程序编写的相关知识2．理解线程的实验步骤在本次试验中，以“生产者-消费者”模型为依据，提供了一个多线程的“生产者-消费者”实例，编写java代码调试运行结果，得出相应的结论。

理解矩阵乘法的实验步骤四、具体实现1.生产者-消费者实例（1）创建一个缓冲信息发送接收通道接口，并创建邮箱盒子类实现，主要代码如下：//通道接口public interface Channelpublic abstract void send(Object item);public abstract Object receive();}//实现接口public class MessageQueue implements Channel{private Vector queue;public MessageQueue(){queue=new Vector();}public void send(Object item){queue.addElement(ite m);}public Object receive(){if(queue.size()==0)return null;elsereturn queue.remove(0);}}（2）创建一个工厂多线程类（启动生产者和消费者），并且添加main函数进行测试，主要代码如下：//工厂类与主方法public class Factory{public Factory(){Channel mailBox=new MessageQueue();Thread producerThread=new Thread(newProducer(mailBox));Thread consumerThread=new Thread(newConsumer(mailBox));producerThread.start();consumerThread.start();}public static void main(String[] args)Factory server=new Factory();}（3）创建一个线程睡眠类，用于测试，主要代码如下：public class SleepUtilities{public static void nap(){nap(NAP_TIME);}public static void nap(int duration){int sleeptime = (int)(NAP_TIME * Math.random());try{ Thread.sleep(sleeptime*1000); }catch (InterruptedException e) {}}private static final int NAP_TIME = 5;（4）创建生产者类实现Runnable，主要代码如下：public class Producer implements Runnable{private Channel mbox;public Producer(Channel mbox){this.mbox=mbox;}public void run(){Date message;while(true){SleepUtilities.nap();message=new Date();System.out.println("Producer produced "+message);mbox.send(message);}}}（5）创建消费者类实现Runnable，主要代码如下：public class Consumer implements Runnable{private Channel mbox;public Consumer(Channel mbox){this.mbox=mbox;}public void run(){Date message;while(true){SleepUtilities.nap();message=(Date)mbox.receive();if(message!=null)System.out.println("Consumer consumed "+message);}}}（6）调试程序，运行结果：2.矩阵乘法实例（1）初始化矩阵(便于观察，这里使用随机数生成矩阵)，主要初始化代码如下matrix1 = new int[m][k];matrix2 = new int[k][n];matrix3 = new int[m][n];//随机初始化矩阵a,bfillRandom(matrix1);fillRandom(matrix2);static void fillRandom(int[][] x){for (int i=0; i<x.length; i++){for(int j=0; j<x[i].length; j++){//每个元素设置为0到99的随机自然数x[i][j] = (int) (Math.random() * 100);}}}（2）打印输出矩阵函数，主要代码如下：static void printMatrix(int[][] x){for (int i=0; i<x.length; i++){for(int j=0; j<x[i].length; j++){System.out.print(x[i][j]+" ");}System.out.println("");}System.out.println("");}（3）创建多线程类，并实现Runnable接口同步对矩阵进行分行计算，主要代码如下：//创建线程,数量 <= 4for(int i=0; i<4; i++){if(index < m){Thread t = new Thread(new MyThread());t.start();}else{break;}synchronized static int getTask(){if(index < m){return index++;}return -1;}}class MyThread implements Runnable{int task;//@Overridepublic void run(){MultiThreadMatrix.threadCount++;while( (task = MultiThreadMatrix.getTask()) != -1 ) {System.out.println("进程:"+Thread.currentThread().getName()+"\t开始计算第"+(task+1)+"行");for(int i=0; i<MultiThreadMatrix.n; i++) {for(int j=0; j<MultiThreadMatrix.k; j++) {MultiThreadMatrix.matrix3[task][i] +=MultiThreadMatrix.matrix1[task][j] *MultiThreadMatrix.matrix2[j][i];}}}MultiThreadMatrix.threadCount--;}（4）通过不断改变矩阵大小，线程数目，，调试程序，运行结果：五、所遇问题与解决方法1.在生产者-消费者多线程试验中，刚开始没有考虑到使用线程睡眠，运行结果速度之快，没法观看数据变化，后面定义了睡眠控制，使得问题得以解决2.在多线程矩阵开发实验中，刚开始定义矩阵太小，测试结果不太明显，后面通过把矩阵改大，并且线程数目不断变化使得结果明显。

操作系统课程设计（一号黑体加粗）用多进程同步方法解决生产者-消费者问题（小二黑体加粗）院系：小二黑体加粗班级：学号：姓名：同组者：时间：目录（小二黑体加粗）一、题目：............................... 错误!未定义书签。

二、设计目的：........................... 错误!未定义书签。

三、总体设计思想概述：................... 错误!未定义书签。

四、说明：............................... 错误!未定义书签。

五、设计要求：........................... 错误!未定义书签。

六、设计方案：........................... 错误!未定义书签。

七、流程图：............................. 错误!未定义书签。

八、运行结果............................. 错误!未定义书签。

九、源程序............................... 错误!未定义书签。

十、总结................................. 错误!未定义书签。

十一、参考文献........................... 错误!未定义书签。

四号黑体一、题目：（标题2，即三号黑体加粗）用多进程同步方法解决生产者-消费者问题。

二、设计目的：通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制。

三、总体设计思想概述：1、生产者—消费者问题是一种同步问题的抽象描述。

2、计算机系统中的每个进程都可以消费或生产某类资源。

当系统中某一进程使用某一资源时，可以看作是消耗，且该进程称为消费者。

3、而当某个进程释放资源时，则它就相当一个生产者。

四、说明：有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1-20这20个整型数。

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

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

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

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

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

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

（1）间接制约。

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

（2）直接制约。

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

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

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

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

实验一(生产者—消费者)一．实验题目生产者与消费者实验二．实验目的加深进程的概念的理解，明确进程与程序的区别，深入认识程序并发执行的实质，理解进程竞争资源的现象，互斥与同步的基本概念,掌握相关的API的使用，了解多线程的并发执行机制，实现线程的同步与互斥的基本方法。

三．实验内容分析已编制的一个“生产者—消费者”实例，并将缺失的代码补充完整，然后调试这段程序，得出最终的结果，并分析此结果，得出相应的结论，尝试改变一些参数，分析这一改变对结果的影响。

四．设计思路和算法1.利用windows提供的API函数CreateSemaphore()创建信号量对象；Create Thread()创建线程；WaitForSingleObject()执行P操作；Release Semaphore()执行V操作；WaitForMultipleObjects()主进程等待线程的结束等函数进行设计。

2.在Windows中，常见的同步对象有：信号量(Semaphore)、互斥量(Mutex) 。

使用这些对象都分为三个步骤，一是创建或者初始化；接着请求该同步对象，随即进入临界区，这一步对应于互斥量的上锁；最后释放该同步对象，这对应于互斥量的解锁。

这些同步对象在主进程中创建，在其子线程中都可五．主要数据结构每个进程有一个进程控制块（ PCB）表示。

进程控制块可以包含如下信息：进程类型标号、进程系统号、进程状态（本程序未用）、进程产品（字符）、进程链指针等等。

系统开辟了一个缓冲区，大小由buffersize指定。

程序中有三个链队列，一个链表。

一个就绪队列（ready），两个等待队列：生产者等待队列（producer）；消费者队列（consumer）。

一个链表（over），用于收集已经运行结束的进程本程序通过函数模拟信号量的原子操作。

六．程序运行结果运行程序后的结果：生产者1准备生产生产者1开始往缓冲区中写数据生产者1开始退出缓冲区...生产者2准备生产生产者2开始往缓冲区中写数据生产者2开始退出缓冲区...消费者1准备消费消费者1开始消费缓冲区中数据消费者1开始退出缓冲区...生产者3准备生产生产者3开始往缓冲区中写数据生产者3开始退出缓冲区...消费者2准备消费消费者2开始消费缓冲区中数据消费者2开始退出缓冲区...生产者4准备生产生产者4开始往缓冲区中写数据生产者4开始退出缓冲区...消费者3准备消费消费者3开始消费缓冲区中数据消费者3开始退出缓冲区...生产者5准备生产生产者5开始往缓冲区中写数据生产者5开始退出缓冲区...消费者4准备消费消费者4开始消费缓冲区中数据消费者4开始退出缓冲区...生产者6准备生产生产者6开始往缓冲区中写数据生产者6开始退出缓冲区...消费者5准备消费消费者5开始消费缓冲区中数据消费者5开始退出缓冲区...生产者7准备生产生产者7开始往缓冲区中写数据生产者7开始退出缓冲区...消费者6准备消费消费者6开始消费缓冲区中数据消费者6开始退出缓冲区...生产者8准备生产生产者8开始往缓冲区中写数据生产者8开始退出缓冲区...消费者7准备消费消费者7开始消费缓冲区中数据消费者7开始退出缓冲区...生产者9准备生产生产者9开始往缓冲区中写数据生产者9开始退出缓冲区...消费者8准备消费消费者8开始消费缓冲区中数据消费者8开始退出缓冲区...生产者10准备生产生产者10开始往缓冲区中写数据生产者10开始退出缓冲区...消费者9准备消费消费者9开始消费缓冲区中数据消费者9开始退出缓冲区...消费者10准备消费消费者10开始消费缓冲区中数据消费者10开始退出缓冲区...七．源程序#include<>#include<>#include<>#include<string>#include<>#define MAX_BUFFER_NUM 10#define INTE_PER_SEC 1000#define MAX_THREAD_NUM 64strict ThreadInfo{into serial;char entity;double delay;into thread_request[MAX_THREAD_NUM];into n_request;};CRITICAL_SECTION PC_Critical[MAX_BUFFER_NUM];into 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(into);into FindProducePositon();into FindBufferPosition(into);into main(void){DWORD wait_for_all;ifstream inFile;for(into i=0;i< MAX_BUFFER_NUM;i++)Buffer_Critical[i] = -1;for(into j=0;j<MAX_THREAD_NUM;j++){for(into 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 >> n_Buffer_or_Critical;();printf("输入文件是:\n");printf("%d \n",(into) 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;(c);while(c!='\n'&& !()){inFile>>Thread_Info[n_Thread].thread_request[Thread_Info[n_Thread].n_request++];(c);}n_Thread++;}for(j=0;j<(into) n_Thread;j++){into Temp_serial = Thread_Info[j].serial;char Temp_entity = Thread_Info[j].entity;double Temp_delay = Thread_Info[j].delay;printf(" \n 线程：%2d %c %f ",Temp_serial,Temp_entity,Temp_delay);into Temp_request = Thread_Info[j].n_request;for(into 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_Critica l,n_Buffer_or_Critical,"semaphore_for_empty");h_mutex = CreateMutex(NULL,FALSE,"mutex_for_update");for(j=0;j<(into)n_Thread;j++){std::string lp ="semaphore_for_produce_";into temp =j;while(temp){char c = (char)(temp%10);lp+=c;temp/=10;}h_Semaphore[j+1]=CreateSemaphore(NULL,0,n_Thread,());}for(i =0;i< (into) 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)(C onsume),&(Thread_Info[i]),0,NULL);}wait_for_all = WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1);printf(" \n \n所有生产和消费已经完成他们的工作。

操作系统课程设计实验报告实验名称: 生产者消费者问题姓名/学号:一、实验目的以生产者和消费者问题为例, 学习Linux和Windows下进程通信、同步机制的具体实现方法, 主要是信号量和共享内存。

熟悉相关系统API的用法。

二、实验内容使用共享内存和信号量机制来实现多个生产者/消费者进程间的通信和同步。

要求在Linux和Windows下分别实现。

缓冲区大小为3, 初始为空。

2个生产者, 随机等待一段时间, 往缓冲区添加数据, 重复6次。

3个消费者, 重复4次。

三、实验环境Ubuntu 10.10 , GCC; Windows 7, VC 6.0;四、程序设计与实现1.Linux下:(1) 数据结构:a.共享内存定义为一个结构, 使得其数据成员更清晰且操作变得简单。

b.共享缓冲区采用循环队列的数据结构，由上面的结构struct buf { int start; int end; int info[BUF_NUM]; }维护。

其中start为队头指针, end为队尾指针, info为数据区域。

(2) 算法:a.大致由三个模块组成:i.主程序(main):ii.创建信号量、共享内存并进行初始化iii.创建生产者、消费者进程, 生产者执行pro_fun(), 消费者执行con_fun()iv.等待所有子进程的结束v.删除信号量、共享内存i.生产者进程(pro_fun):ii.通过key获得信号量、共享内存的ID, 将内存添加到自己的地址空间iii.P(empty), P(mutex), Add(data), V(mutex), V(full)iv.解除和共享内存的关联i.消费者进程(con_fun):ii.通过key获得信号量、共享内存的ID, 将内存添加到自己的地址空间iii.P(full), P(mutex), Add(data), V(mutex), V(empty)iv.解除和共享内存的关联循环队列部分:加入数据: info[end] = value; end = (end + 1) % 3;取出数据: temp = info[start]; info[start] = 0; (start = start + 1)%3; return temp;(3) 程序流程图:a.主函数：b.生产者进程:c.消费者进程和生产者类似4.Windows 下:(1) 数据结构:和Linux大致相同(2) 算法:a.创建的子进程调用正在执行的文件本身, 通过main函数的参数区分主进程和生产者、消费者进程。

生产者和消费者实验报告【实验目的】1.加深对进程概念的理解，明确进程和程序的区别。

2.进一步认识并发执行的实质。

3.验证用信号量机制实现进程互斥的方法。

4.验证用信号量机制实现进程同步的方法。

【实验要求】用c语言编程搭建“生产者和消费者”经典进程通信问题的环境。

要求程序运行时，按任意键停止，显示当前系统的各个参数的值。

提交实验报告，以及相关程序列表。

打包成附件上传。

【实验环境】Visual C++6.0【实验内容】1.了解经典同步问题“生产者和消费者”生产者与消费者可以通过一个环形缓冲池联系起来，环形缓冲池由几个大小相等的缓冲块组成，每个缓冲块容纳一个产品。

每个生产者可不断地每次往缓冲池中送一个生产产品，而每个消费者则可不断地每次从缓冲池中取出一个产品。

指针i和指针j分别指出当前的第一个空缓冲块和第一个满缓冲块。

2.分析和理解（1）既存在合作同步问题，也存在临界区互斥问题合作同步：当缓冲池全满时，表示供过于求，生产者必须等待，同时唤醒消费者；当缓冲池全空时，表示供不应求，消费者应等待，同时唤醒生产者。

互斥：缓冲池显然是临界资源，所在生产者与消费都要使用它，而且都要改变它的状态。

（2）基于环形缓冲区的生产者与消费者关系形式描述：公用信号量mutex：初值为1，用于实现临界区互斥生产者私用信号量empty：初值为n，指示空缓冲块数目消费者私用信号量full：初值为0，指示满缓冲块数目整型量i和j初值为0，i指示首空缓冲块序号，j指示首满缓冲块序号（3）PV原语var mutex,empty,full:semaphore;i,j:integer;buffer:array[0...n-1] of item;i:=j:=1;Procedure producer;beginwhile true dobeginproduce a product;P(empty);P(mutex);buffer(i):=product;i:=(i+1) mod n;V(mutex);V(full);end;end;Procedure consumer;beginP(full);P(mutex);goods:=buffer(j);j:=(j+1) mod n;V(mutex);V(empty);consume a product;end;end;【实验源程序代码】#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]; //各线程的handleDWORD 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,&con sumerID[i]);if (hThreads[i]==NULL) return -1;}while(g_continue){if(getchar()){ //按回车后终止程序运行g_continue = false;}}return 0;}//生产一个产品。

实验报告第页专业_______软件工程_____ 班级_________ 学号_____ 姓名实验日期：年月日报告退发(订正、重做)课程实验名称生产者与消费者问题、读者—写者问题一、实验目的1. 实现生产者消费者问题模拟2. 进一步掌握P，V如何解决同步和互斥问题二、实验环境1. Windows或Linux平台2. Eclipse、Visual Studio 2005或GCC三、实验内容、步骤和结果分析实验内容：实现生产者消费者问题模拟，显示每次添加和读取数据时缓冲区的状态，生产者和消费者可用线程模拟。

1.一个大小为10的缓冲区，初始为空。

2. 五个生产者:若缓冲区可以加入数据，则示意进入生产过程（打印出生产者ID），往缓冲区添加数据，随机等待一段时间。

若缓冲区已满，等待消费者取走数据后再添加。

3. 五个消费者：若缓冲区可以读取数据，则示意进入消费过程（打印出消费者ID），从缓冲区读取数据，随机等待一段时间；若缓冲区为空，等待生产者添加数据后再读取。

四、讨论（说明实验过程中遇到的问题及解决办法；未解决/需进一步研讨的问题或建议新实验方法等）(请利用实验二中所给的各个版本信号量类来完成实验三。

若选用Windows平台，要求一定要选用这三个文件夹中的某个信号量类Semaphore来完成实验，否则实验报告视为缺交；若选用Linux平台，也要求参照已给出的三个版本的Semaphore类的接口，先定义一个Linux版本的C++类class Semaphore，并在该类基础上完成实验，提交实验报告时请附上自定义的Semaphore类。

读者—写者问题：#include<windows.h>#include"semaphore.h"#include"thread.h"#include<iostream>using namespace std;Semaphore rmutex(1);Semaphore wmutex(1);int count=0;unsigned int WINAPI Reader(void *p){while(TRUE){rmutex.P();count++;rmutex.V();if(count == 1)wmutex.P();cout << GetCurrentThreadId() << "reading the student's table"<<endl;rmutex.P();count--;rmutex.V();if(count == 0)wmutex.V();Sleep(rand()%1000);}}unsigned int WINAPI Writer(void *p){while(TRUE){wmutex.P();cout << GetCurrentThreadId() << "writting the student's table"<<endl;wmutex.V();Sleep(rand()%1000);}}int main(){HANDLE hThread[2];hThread[0] = startThread(Reader,NULL);hThread[1] = startThread(Writer,NULL);::WaitForMultipleObjects(2,hThread,TRUE,INFINITE);CloseHandle(hThread[0]);CloseHandle(hThread[1]);return 0;}生产者与消费者问题：#include<windows.h>#include"semaphore.h"#include"thread.h"#include<iostream>using namespace std;Semaphore full(5);Semaphore empty(5);Semaphore mutex(1);int count=0;unsigned int WINAPI Producer(void *p){while(TRUE){empty.P();mutex.P();cout << GetCurrentThreadId() << " produce!"<<endl;mutex.V();full.V();Sleep(rand()%1000);}}unsigned int WINAPI Consumer(void *p){while(TRUE){full.P();mutex.P();cout << GetCurrentThreadId() << " consum!"<<endl;mutex.V();empty.V();Sleep(rand()%1000);}}int main(){HANDLE hThread[2];hThread[0] = startThread(Producer,NULL);hThread[1] = startThread(Consumer,NULL);::WaitForMultipleObjects(2,hThread,TRUE,INFINITE);CloseHandle(hThread[0]);CloseHandle(hThread[1]); return 0;}。