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

实验三生产者-消费者问题的实现实验类型验证性实验实验目的通过生产者-消费者问题的模拟，加深对进程同步、共享存储器通信的理解。

实验要求实现生产者消费者问题模拟，显示每次添加和读取数据时缓冲区的状态，生产者和消费者用进程模拟，缓冲区用共享内存来实现。

一个大小为3的缓冲区，初始为空；2个生产者：随机等待一段时间，往缓冲区添加数据，若缓冲区已满，等待消费者取走数据后再添加，重复6次。

3个消费者：随机等待一段时间，从缓冲区读取数据，若缓冲区为空，等待生产者添加数据后再读取，重复4次。

实验指导一、共享存储区通信1、共享存储区机制的概念共享存储区（Share Memory）是UNIX系统中通信速度最高的一种通信机制。

该机制可使若干进程共享主存中的某一个区域，且使该区域出现（映射）在多个进程的虚地址空间中。

另一方面，一个进程的虚地址空间中又可连接多个共享存储区，每个共享存储区都有自己的名字。

当进程间欲利用共享存储区进行通信时，必须先在主存中建立一共享存储区，然后将它附接到自己的虚地址空间上。

此后，进程对该区的访问操作，与对其虚地址空间的其它部分的操作完全相同。

进程之间便可通过对共享存储区中数据的读、写来进行直接通信。

应当指出，共享存储区机制只为进程提供了用于实现通信的共享存储区和对共享存储区进行操作的手段，然而并未提供对该区进行互斥访问及进程同步的措施。

因而当用户需要使用该机制时，必须自己设置同步和互斥措施才能保证实现正确的通信。

2、涉及的系统调用（1）shmget( )创建、获得一个共享存储区。

系统调用格式：shmid=shmget(key,size,flag)该函数使用头文件如下：#include<sys/types.h>#include<sys/ipc.h>#include<sys/shm.h>参数定义int shmget(key,size,flag);key_t key;int size,flag;其中：key是共享存储区的名字；(唯一标识共享内存的键值。

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

操作系统课程设计实验报告实验名称: 生产者消费者问题姓名/学号:一、实验目的以生产者和消费者问题为例, 学习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函数的参数区分主进程和生产者、消费者进程。

计算机操作系统课程设计报告《生产者---消费者问题》《计算机操作系统》课程设计题目：生产者---消费者问题专业：软件工程年级：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篇一、实验目的1. 加深对进程概念的理解，明确进程和程序的区别。

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

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

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

二、实验环境1. 操作系统：Windows 102. 编程语言：C语言3. 开发工具：Visual Studio三、实验内容1. 生产者和消费者模型介绍生产者和消费者模型是操作系统中常见的一种并发控制模型，用于解决多个进程之间的同步和互斥问题。

在该模型中，生产者负责生成数据，消费者负责消费数据。

生产者和消费者通过共享资源（如缓冲区）进行通信。

2. 实验设计（1）环形缓冲区为了实现生产者和消费者的同步，我们设计了一个环形缓冲区，由若干个大小相等的缓冲块组成。

每个缓冲块可以容纳一个产品。

环形缓冲区的指针分别指向当前的第一个空缓冲块和第一个满缓冲块。

（2）信号量为了实现进程互斥和同步，我们使用了三个信号量：① 公用信号量：用于实现临界区互斥，初始值为1。

② 生产者私用信号量：用于实现生产者与消费者之间的同步，初始值为0。

③ 消费者私用信号量：用于实现生产者与消费者之间的同步，初始值为0。

（3）生产者进程生产者进程负责生成数据，并将数据存入环形缓冲区。

当环形缓冲区满时，生产者进程等待；当环形缓冲区有空位时，生产者进程继续生成数据。

（4）消费者进程消费者进程负责从环形缓冲区中取出数据并消费。

当环形缓冲区空时，消费者进程等待；当环形缓冲区有数据时，消费者进程继续消费数据。

3. 实验步骤（1）创建生产者进程和消费者进程。

（2）初始化信号量。

（3）运行生产者进程和消费者进程。

（4）按任意键停止程序，显示当前系统的各个参数的值。

四、实验结果与分析1. 实验结果通过运行实验程序，我们可以观察到生产者和消费者进程的运行情况。

当按下任意键停止程序时，程序将显示当前系统的各个参数的值，包括环形缓冲区的空位数量、生产者和消费者的状态等。

2. 分析（1）互斥：通过公用信号量实现生产者和消费者对环形缓冲区的互斥访问，防止了同时操作缓冲区的问题。

实验3 经典同步互斥问题1.实验目的·通过编写程序熟悉并发，同步/互斥，死锁等概念2.实验内容[基本要求]编写Linux环境下C程序，实现3个经典的同步/互斥问题[具体要求]·生产者/消费者问题设计思路：1）首先建立缓冲池，循环队列#define BUFFSIZE 9 // 缓冲池大小struct queue_type //缓冲池队列{int buff[BUFFSIZE];int front; //队头，消费者从对头取出"产品”int rear; //队尾，生产者从队尾放入"产品“}Q={{0},0,0};2）设置信号量实现互斥sem_t pro_empty; // 生产者私有信号量，表示空缓冲区数目。

sem_t con_full; //消费者私有变量，表示有产品的缓冲区数目。

sem_t mutex; //实现对临界区互斥访问的信号量3）设计生产者函数生产者必须首先申请空缓冲区，缓冲区有空闲才能生产sem_wait(&pro_empty);然后进入缓冲区生产，进入之前利用mutex互斥sem_wait(&mutex); //信号量申请缓冲区互斥Q.buff[Q.rear] = 1; //将产品放入rear所指向的缓冲区print();Q.rear = (Q.rear+1) % BUFFSIZE;//注意要模，因为是循环队列sem_post(&mutex); //释放互斥sem_post(&con_full);//释放满缓冲区4）设计消费者函数消费者必须首先申请满缓冲区，缓冲区有东西才能消费sem_wait(&con_full);然后进入缓冲区消费，进入之前利用mutex互斥sem_wait(&mutex);Q.buff[Q.front] = 0; //从front所指向的缓冲区取产品print();Q.front = (Q.front+1) % BUFFSIZE;sem_post(&mutex);//释放队列互斥sem_post(&pro_empty);// //释放空缓冲区·读者问题设计思路：1）设置互斥锁pthread_mutex_t writer_lock = PTHREAD_MUTEX_INITIALIZER;//同一时间只能一个人写文件,互斥pthread_mutex_t access_readercount = PTHREAD_MUTEX_INITIALIZER;//同一时间只能有一个人访问readerCnt2）设计写者函数进入临界区写，进入之前利用互斥锁互斥pthread_mutex_lock(&writer_lock);write();pthread_mutex_unlock(&writer_lock);3）设计读者优先函数如果有一个读者在读，则后面的读者来到都可以读，所以要把所有写者锁上pthread_mutex_lock(&access_readercount);//临界区互斥readercount++;if(readercount == 1){pthread_mutex_lock(&writer_lock);//把读者锁上}pthread_mutex_unlock(&access_readercount);读数据，读之前利用互斥锁互斥pthread_mutex_unlock(&access_readercount);read();pthread_mutex_lock(&access_readercount);如果最后一个读者退出，则要把原来锁上写者的锁打开pthread_mutex_lock(&access_readercount);readercount--;if(readercount == 0){pthread_mutex_unlock(&writer_lock);}pthread_mutex_unlock(&access_readercount);·写者问题设计思路：1）设置互斥锁//实现读者读时互斥pthread_mutex_t access_readercount = PTHREAD_MUTEX_INITIALIZER;//实现写者写时互斥pthread_mutex_t access_writercount = PTHREAD_MUTEX_INITIALIZER;//实现把写者锁上pthread_mutex_t writer_lock = PTHREAD_MUTEX_INITIALIZER;//实现把一个读者锁上pthread_mutex_t reader_lock = PTHREAD_MUTEX_INITIALIZER;//实现把成千上万读者锁上pthread_mutex_t outer_lock = PTHREAD_MUTEX_INITIALIZER;2）设计写者优先函数如果第一个写者来了，那么禁止所有读者pthread_mutex_lock(&access_writercount);{//临界区,希望修改writercount,独占writercountwritercount++;//写者数量加1if(writercount == 1){//后续的读者加入待读队列pthread_mutex_lock(&reader_lock);}}pthread_mutex_unlock(&access_writercount);写数据，写之前互斥pthread_mutex_lock(&writer_lock);{//临界区，限制只有一个写者修改数据write();}pthread_mutex_unlock(&writer_lock);最后一个写者走了，则释放之前所有被禁止的读者pthread_mutex_lock(&access_writercount);{//临界区,希望修改writercount,独占writercountwritercount--;//写者数量减1if(writercount == 0){//释放待读序列中的读者pthread_mutex_unlock(&reader_lock);}}pthread_mutex_unlock(&access_writercount);3）·哲学家问题只有当哲学家的左右两只筷子均可以用的时候，才允许其拿起筷子进餐，否则该哲学家一直请求左边的筷子,若为非阻塞状态（左边的筷子信号量为1则直接占有，信号量为0则进入阻塞状态），则拿起，然后测试右手筷子是什么状态，右边的筷子若信号量为0，则阻塞，进入等待，非阻塞，则吃设计思路：1）设置左右手筷子int right = (id + 1) % PHILO_NUM;int left = id;2）思考状态，然后此哲学家先处于睡眠，然后状态变为饥饿case THINKING:usleep(300);state = HUNGRY;strcpy(ptrState,"thinking");break;3）饥饿状态，则去拿筷子case HUNGRY:if(sem_wait(&chopsticks[left]) == 0){//左筷子非阻塞状态if(sem_trywait(&chopsticks[right]) == 0){//测试右筷子，若为非阻塞,则拿起strcpy(ptrState,"eating ");state = EATING;//状态变为吃}else{state = THINKING;//拿不到筷子，变为思考状态sem_post(&chopsticks[left]);//释放已经请求的得到的左筷子}}break;4）吃状态，释放左右手筷子，之后状态变为思考sem_post(&chopsticks[left]);sem_post(&chopsticks[right]);usleep(500);state = THINKING;strcpy(ptrState,"thinking");break;·代码有注释，提交实验报告和源代码[进一步要求]·多个生产者和消费者在主函数中可以输入你想设置的生产者和消费者数目printf("please input the producers number: ");scanf("%d",&M);printf("please input the consumers number: ");scanf("%d",&N);·多个读者和写者，考虑读者优先或是写者优先宏定义读者写者数目#define N_WRITER 3 //写者数目#define N_READER 5 //读者数目·用区别于示例代码的思想实现哲学家问题利用了sem_trywait()函数·可视化展示输出结果。

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

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

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

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

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

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

（1）间接制约。

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

（2）直接制约。

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

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

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

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

实验报告第页专业_______软件工程_____ 班级_________ 学号_____ 姓名实验日期：年月日报告退发(订正、重做)课程实验名称生产者与消费者问题、读者—写者问题一、实验目的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;}。

实验报告（学生打印后提交）实验名称: 生产者和消费者问题实验时间: 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、实现对经典的生产者—消费者问题的模拟，以便更好的理解此经典进程同步问题。

生产者－消费者问题是典型的PV 操作问题，假设系统中有一个比较大的缓冲池，生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中，而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。

缓冲池被占用时，任何进程都不能访问。

2、每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。

在这种情况下，生产者消费者进程同步，因为只有通过互通消息才知道是否能存入产品或者取走产品。

他们之间也存在互斥，即生产者消费者必须互斥访问缓冲池，即不能有两个以上的进程同时进行。

三、生产者和消费者原理分析在同一个进程地址空间内执行两个线程。

生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。

消费者线程从缓冲区中获得物品，然后释放缓冲区。

当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放一个空缓冲区。

当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻挡，直到新的物品被生产出来。

四、生产者与消费者功能描述：生产者功能描述：在同一个进程地址空间内执行两个线程。

生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。

当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。

消费者功能描述：消费者线程从缓冲区获得物品，然后释放缓冲区，当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。

五、实验环境操作系统环境：Windows 系统。

编程语言：C#。

中南大学操作系统实验报告实验内容：Java多线程模拟生产者消费者问题实验时间：2014年5月指导老师：胡小龙老师姓名：代巍班级：信安1201班学号：**********一、实验目的对操作系统的整体进行一个模拟，通过实践加深对各个部分的管理功能的认识，还能进一步分析各个部分之间的联系，最后达到对完整系统的理解。

可以提高运用操作系统知识解决实际问题的能力；锻炼实际的编程能力，要达到以下要求。

（1）掌握进程（线程）的同步与互斥。

（2）掌握生产者消费者问题的实现方法。

（3）掌握多线程编程方法。

二、实验内容实现生产者消费者问题。

（1）假设循环缓冲队列共有多个缓冲单元。

（2）生产者线程的工作：生产出一个产品（即产生一个产品编号），按顺序往缓冲队列中“空”的缓冲单元放产品。

（3）消费者线程与的工作：从缓冲队列装有产品的缓冲单元中取出一个产品（即产品编号）。

（4）保证两个线程间的互斥和同步（5）在界面上打印缓冲队列的变化情况三、实验原理（1）生产者—消费者问题是一种同步问题的抽象描述。

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

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

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

模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。

生产者把数据放入缓冲区，而消费者从缓冲区取出数据。

大概的结构如下图。

四、实验思想概述在操作系统中,线程有时被称为轻量级进程,是CPU使用的基本单位,它与属于同一进程的其他进程共享其他代码段、数据段和其他操作系统资源。

在Java中,线程的建立有两种方法:继承Thread类和实现Runnable接口。

其中,采用实现Runnable接口建立线程的好处是允许同时继承其他类从而实现多继承,并且在Java中,可采用synchronized或Object类的方法wait(),notify(),notifyAll()来实现多线程同步。

《操作系统》实验报告2016年1月8日指导教师对实验报告的评语成绩：指导教师签字：年月日一、设计目标●完成N个生产者和M个消费者线程之间的并发控制，N、M不低于30，数据发送和接收缓冲区尺寸不小于20个（每个产品占据一个）。

●其中生产者线程1、3、5、7、9生产的产品供所有奇数编号的消费者线程消费，只有所有奇数编号的消费者线程都消费后，该产品才能从缓冲区中撤销。

●其中生产者线程2、4、6、8、10生产的产品所有偶数编号的消费者线程都可消费，任一偶数编号消费者线程消费该消息后，该产品都可从缓冲区中撤销。

●其中11-20号生产者线程生产的产品仅供对应编号的消费者线程消费。

●其他编号生产者线程生产的产品可由任意的消费者线程消费。

●每个生产线程生产30个消息后结束运行。

如果一个消费者线程没有对应的生产者线程在运行后，也结束运行。

所有生产者都停止生产后，如果消费者线程已经没有可供消费的产品，则也退出运行。

二、背景知识说明原理利用进程间共享的信号量、互斥锁等控制线程同步。

相关函数说明pthread_create()：创建一个线程pthread_join()：阻塞当前的线程，直到另外一个线程运行结束pthread_mutex_init()：初始化互斥锁pthread_mutex_lock()：占有互斥锁（阻塞操作）pthread_mutex_unlock()：释放互斥锁sem_wait()：获取信号量sem_post()：释放信号量三、设计设计环境Linux操作系统（ubuntu12.04）gcc 4.6c语言Posix线程库编译命令：gcc consumer.c -lpthread -o consumer概要设计及详细设计图注释：(1)图：主函数流程(2)图：生产者流程(3)图：消费者流程（1）图(2) 图（3）图重要代码注释：#include<stdio.h>#include<malloc.h>#include<pthread.h>#include<semaphore.h>#define BUFFER_SIZE 30#define OVER (-1)struct Product{int tid;int data;};struct producers{//定义生产者条件变量结构struct Product buffer[BUFFER_SIZE];//缓冲区sem_t sem_read; // 读信号量sem_t sem_write; // 写信号量pthread_mutex_t wlock; // 缓冲区写锁pthread_mutex_t rlock; // 缓冲区读锁pthread_mutex_t lock; // thread_count的读写锁int readpos , writepos;//读写位置};struct producers buffer;int thread_count = 30; //存活生产者计数//用于在线程内部标识线程IDint ids[30] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30}; int count = 0; // 计数消费产品数量int pcount = 0; // 计数生产产品数量void init(){//初始化相关锁和变量以及信号量buffer.readpos = 0;buffer.writepos = 0;//写信号量比缓冲区小1，防止缓冲区满和缓冲区空分不清sem_init(&buffer.sem_write, 0, BUFFER_SIZE-1);sem_init(&buffer.sem_read, 0, 0);pthread_mutex_init(&buffer.wlock, NULL);pthread_mutex_init(&buffer.rlock, NULL);pthread_mutex_init(&buffer.lock, NULL);}void put(int tid, int data){//缓冲区中放入一个数据sem_wait(&buffer.sem_write);//生产前先加锁，已防止其他线程同时生产pthread_mutex_lock(&buffer.wlock);buffer.buffer[buffer.writepos].tid = tid;buffer.buffer[buffer.writepos].data = data;buffer.writepos ++;++ pcount;if( buffer.writepos >= BUFFER_SIZE )buffer.writepos = 0;pthread_mutex_unlock(&buffer.wlock);sem_post(&buffer.sem_read);}//读数据并移走struct Product * get(int tid){struct Product * produce = NULL;//消费前先上锁，以防止其他线程同时消费pthread_mutex_lock(&buffer.rlock);// 如果生产者线程没有全部退出，或者缓冲区内仍有产品，则说明可以尝试去获取产品if(thread_count > 0 || buffer.readpos != buffer.writepos){//从信号量的值减去一个“1”，但它永远会先等待该信号量为一个非零值才开始做减法sem_wait( &buffer.sem_read );int pos = buffer.readpos;// 在已有产品中迭代，查找适合的产品while(pos != buffer.writepos){int id = buffer.buffer[pos].tid;if(id >10 && id <=20 && tid == id){ //如果产品是的生产者线程号10<id<=20 则可以供和它的线程号相同的消费者线程消费produce = (struct Product *)malloc(sizeof(struct Product));produce->tid = id;produce->data = buffer.buffer[pos].data;break;}else if(id <= 10 && (id%2 == tid%2)){ //如果产品是的生产者线程号<=10 则可以供和它的线程号奇偶性相同的消费者消费produce = (struct Product *)malloc(sizeof(struct Product));produce->tid = id;produce->data = buffer.buffer[pos].data;break;}else if(id > 20){ //如果产品是的生产者线程号>20则可以供任何消费者消费produce = (struct Product *)malloc(sizeof(struct Product));produce->tid = id;produce->data = buffer.buffer[pos].data;break;}pos = (pos+1)%BUFFER_SIZE;}if( produce ){ //如果取得了产品，消费计数+1，将在队头的元素覆盖到被取走的位置++ count;buffer.buffer[pos].tid = buffer.buffer[buffer.readpos].tid;buffer.buffer[pos].data = buffer.buffer[buffer.readpos].data;++ buffer.readpos;}if( buffer.readpos >= BUFFER_SIZE )buffer.readpos = 0;//如果取得了产品则释放一个缓冲区可写的信号量，否则释放一个可读的信号量if( produce )sem_post(&buffer.sem_write);elsesem_post(&buffer.sem_read);pthread_mutex_unlock(&buffer.rlock);}elsepthread_mutex_unlock(&buffer.rlock);return produce;}void *producer(void *data){ //每个线程循环生产30个产品int tid = *((int *)data);int n;for(n = 1; n <= 30; n++){printf("producer %d product %d \n", tid, n);put(tid, n);}// 每退出一个生产者线程后，thread_count 减1pthread_mutex_lock(&buffer.lock);-- thread_count;pthread_mutex_unlock(&buffer.lock);return NULL;}void *consumer(void * data){int tid = *((int *)data);struct Product *d = NULL;while(1){d = get(tid);if( d ) {printf("consumer %d consum %d from Producer %d \n", tid, d->data,d->tid);free(d);}pthread_mutex_lock(&buffer.lock);// 当所有生产者线程已退出，且缓冲区内已没有该线程可消费的产品时，退出该线程if(d == NULL && thread_count == 0 ){pthread_mutex_unlock(&buffer.lock);break;}elsepthread_mutex_unlock(&buffer.lock);}return NULL;}int main(void){pthread_t th_a[30], th_b[30];void *retval;init(&buffer);int i;for(i = 0; i<30; ++i){ // 创建生产者和消费者pthread_create(&th_a[i], NULL, producer, &ids[i]);pthread_create(&th_b[i], NULL, consumer, &ids[i]);}for(i = 0; i<30; ++i){ // 将线程加入到主线程组pthread_join(th_a[i], &retval);pthread_join(th_b[i], &retval);}printf("product %d products\n", pcount);printf("consume %d products\n", count);return 0;}四、测试测试数据文件格式测试数据由程序内部生成运行结果分析运行./consumer cat > output.txt 将输出结果保存在output.txt中待分析。

实验一生产者和消费者问题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、实验心得通过做生产者消费者问题这个实验，让我更加明确了两者之间的联系和基本的同步互斥算法，了解多线程并发执行机制是怎样的，线程间的同步和互斥又是怎样的，还有缓冲区的在其中作用是什么。

格式： V。IDEnterCriticalSection( LPCRITICAL_SECTI。NIpCnticalSection )； LeaveCriticalSection的用法 功能：释放指定临界区对象的所有权。 格式： V。IDLeaveCriticalSection( LPCRITICAL.SECTI。NIpCriticalSection )； 2)程序结构 MI-I和序结构图 3)数据结构 (1)用一个整型数组Buffer-Critical来代表缓冲区。不管是生产产品还是对已有产品的消费都
Fer(inti-∙zi<R.reqvestHunU∙∙)
n_tħrei。.re<∣ι>tst[1]-((Thread!i⅞Fφ∙)(p))->thre⅛d.reqvest(1];
$10，P(LSl刊)；
F∙r(l-∙U<R..req<∣p⅝tHuAU*∙)<
printfCXoo⅞uι⅞erVdrequesttoconς∣>aeVdpro^uct∖n-t∙-serlil.n_thr^a<l_requ«Mlt_for_sefuiphorPVanFarSinglp。bject(b_S^Mphor»(ii_thrp^d_reqiiest[i])v*-1);
文件G)⅛M∙Z)2«(X)收就")工具(D隅船。i) r^i∙-。CAftφct∙taisg4S∙S∖n<s∖Mmm6lr∙t0tA4面3f⅞文件夹∖*JfFl 文件和文件关任务 J创建一个新文件夹 θ将这个文件英宣布到 WHtb H共享，及伴英 IT*+6Y。rkSP∙c∙ Urn C*÷Ssιrc∙6KB Un VV忖Inttllistns 25KB 10簪巷

操作系统课程设计实验报告实验名称：生产者消费者问题姓名/学号：一.实验目的1.学习掌握操作系统中进程之间的通信2.理解掌握使用信号量机制来多进程互斥访问共享内存区的控制3.学习进程的创建及控制，共享内存区的创建和删除，信号量的创建使用删除二.实验内容•一个大小为3的缓冲区，初始为空，每个缓冲区能存放一个长度若为10个字符的字符串。

•2个生产者–随机等待一段时间，往缓冲区添加数据，–若缓冲区已满，等待消费者取走数据后再添加–重复6次•3个消费者–随机等待一段时间，从缓冲区读取数据–若缓冲区为空，等待生产者添加数据后再读取–重复4次说明：•显示每次添加和读取数据的时间及缓冲区的状态•生产者和消费者用进程模拟，缓冲区用共享内存来实现三.实验环境VMware Fushion8:Windows和ubuntu14.10四.程序设计与实现1、Windows下：A：主要函数说明1.PROCESS_INFORMATION StartClone(int nCloneID)功能：创建一个克隆的进程并赋于其ID值，并返回进程和线程信息2.CreateProcess：创建进程3.CreateSemaphore()：创建信号量4.CreateFileMapping()：在当前运行的进程中创建文件映射对象，模拟共享内存区5.MapViewOfFile()：在此文件映射基础上创建视图映射到当前应用程序的地址空间B：程序流程图（下图）C：实验结果：2、Linux下：A：主要函数说明1.void(p)：申请缓冲区2.void(v)：释放缓冲区3.shmget()：用来获得共享内存区域的ID，如果不存在这个内存区，就创建这个共享内存区。

4.semget()：返回信号量集的Id，如果不存在就创建这个信号量集B：程序流程图C:实验结果五. 实验收获与体会1、进一步熟悉了Windows 、Linux 中进程的创建与管理2、掌握了WINDOWS 和Linux 下进程之间的通信：Windows 主要在于句柄的获取并用于API 函数的调用，并利用文件映射创建共享缓冲区；Linux 主要使用信号量机制和相关API的调用。