操作系统之进程(生产者_消费者)实验报告
操作系统实验三 生产者——消费者问题
操作系统实验三：生产者——消费者问题一、基本信息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 操作。
生产者消费者实验报告
生产者消费者实验报告生产者消费者实验报告引言：生产者消费者模型是计算机科学中的一个经典问题，用于解决多线程并发访问共享资源的同步问题。
在本实验中，我们通过编写一个简单的Java程序来模拟生产者消费者模型，并观察其运行结果和效果。
一、实验背景生产者消费者模型是一种常见的并发模型，用于解决多线程访问共享资源时可能出现的数据竞争和同步问题。
在该模型中，生产者负责生产数据并将其放入共享缓冲区，而消费者则负责从缓冲区中取出数据进行消费。
为了确保生产者和消费者之间的同步与互斥，需要使用合适的同步机制，如信号量、互斥锁等。
二、实验目的本实验的主要目的是通过编写一个简单的生产者消费者程序，验证该模型在多线程环境下的正确性和效果。
我们将通过观察程序的输出结果和运行时间来评估其性能，并分析其中可能存在的问题和改进空间。
三、实验设计1. 编写生产者类和消费者类：我们首先定义了一个共享缓冲区，用于存储生产者生产的数据。
然后，我们编写了一个生产者类和一个消费者类，分别实现了生产者和消费者的逻辑。
在生产者类中，我们使用了一个循环来模拟生产者不断地生产数据，并将其放入缓冲区。
而在消费者类中，我们同样使用了一个循环来模拟消费者不断地从缓冲区中取出数据进行消费。
2. 同步机制的选择：为了保证生产者和消费者之间的同步与互斥，我们选择了信号量作为同步机制。
在生产者类中，我们使用一个信号量来控制缓冲区的可用空间，当缓冲区已满时，生产者将等待，直到有可用空间。
而在消费者类中，我们同样使用一个信号量来控制缓冲区的可用数据，当缓冲区为空时，消费者将等待，直到有可用数据。
3. 实验参数的设置：为了模拟真实的生产者消费者场景，我们设置了以下参数：- 缓冲区大小：10- 生产者数量：3- 每个生产者生产的数据量：1000- 消费者数量：2四、实验结果与分析在运行实验程序后，我们观察到以下结果：1. 生产者和消费者之间的同步与互斥得到了有效保证，生产者在缓冲区已满时会等待，直到有可用空间；消费者在缓冲区为空时会等待，直到有可用数据。
操作系统实验报告生产者消费者问题
操作系统课程设计一．实验目标完成N个生产者和M个消费者线程之间的并发控制，N、M不低于30，数据发送和接收缓冲区尺寸不小于20个（每个产品占据一个）。
其中生产者线程1、3、5、7、9生产的产品供所有奇数编号的消费者线程消费，只有所有奇数编号的消费者线程都消费后，该产品才能从缓冲区中撤销。
其中生产者线程2、4、6、8、10生产的产品所有偶数编号的消费者线程都可消费，任一偶数编号消费者线程消费该消息后，该产品都可从缓冲区中撤销。
其中11-20号生产者线程生产的产品仅供对应编号的消费者线程消费。
其他编号生产者线程生产的产品可由任意的消费者线程消费。
每个生产线程生产30个消息后结束运行。
如果一个消费者线程没有对应的生产者线程在运行后，也结束运行。
所有生产者都停止生产后，如果消费者线程已经没有可供消费的产品，则也退出运行。
二．实验原理2.1原理生产者与消费者线程采用posix互斥锁机制进行互斥进入各自的代码段，只有采用互斥锁临界区代码段才可以不被打扰的执行；同步机制采用的是posix条件变量pthread_cond_wait和pthraed_cond_signal进行同步的。
线程间的通信采用的是共享内存机制。
（注：所有的共享内存块是在进程里建立的，线程只需链接上各自的共享内存块即可，每一块共享内存的大小是100）. 在这里共享内存设置成一个100的数组。
具体实施：（1）为1.3.5.7.9建立一个共享内存1号，1.3.5.7.9生产者线程生产的产品都放入这块共享内存缓冲区，所有奇数的消费者线程要消费的话，只需在消费者线程中链接上这块共享内存，就可以直接消费1.3.5.7.9生产者线程生产的产品。
（2）为2.4.6.8.10建立一块共享内存2号。
2.4.6.8.10生产的产品都放入2号共享内存缓冲区，所有的偶数的消费者线程只要链接上2号缓冲区，就可以消费2.4.6.8.10生产的产品。
当偶数消费者线程消费产品后，产品即可从缓冲区撤销，方法是在消费线程里将消费的产品在共享内存数组里置0。
生产者消费者问题实验报告
操作系统课程设计实验报告实验名称：生产者消费者问题姓名/学号：一、实验目的以生产者和消费者问题为例，学习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.主程序(main)：i.创建信号量、共享内存并进行初始化ii.创建生产者、消费者进程，生产者执行pro_fun()，消费者执行con_fun()iii.等待所有子进程的结束iv.删除信号量、共享内存b.生产者进程(pro_fun)：i.通过key获得信号量、共享内存的ID，将内存添加到自己的地址空间ii.P(empty)，P(mutex)，Add(data)，V(mutex)，V(full)iii.解除和共享内存的关联c.消费者进程(con_fun)：i.通过key获得信号量、共享内存的ID，将内存添加到自己的地址空间ii.P(full)，P(mutex)，Add(data)，V(mutex)，V(empty)iii.解除和共享内存的关联d.循环队列部分：加入数据：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函数的参数区分主进程和生产者、消费者进程。
操作系统实验报告生产者消费者问题
《操作系统课程设计》实验报告生产者消费者问题2013年12 月25 日一设计目标运用条件变量和互斥锁原理实现线程同步问题，解决生产者消费者问题1.1 背景知识说明在Linux环境下需要使用POSIX库进行设计实现，POSIX是Portable Operating System Interface of Unix的缩写。
由IEEE（Institute of Electrical and Electronic Engineering）开发，由ANSI和ISO 标准化。
POSIX的诞生和Unix的发展是密不可分的，Unix于70年代诞生于贝尔实验室，并于80年代向美各大高校分发V7版的源码以做研究。
加利福尼亚大学伯克利分校在V7的基础上开发了BSD Unix。
后来很多商业厂家意识到Unix的价值也纷纷以贝尔实验室的System V或BSD 为基础来开发自己的Unix，较著名的有Sun OS，AIX，VMS。
文档收集自网络，仅用于个人学习基于posix的线程标准库是pthreadPOSIX线程（POSIX Thread），简称Pthread，是线程的POSIX 标准。
该标准定义了创建和操纵线程的一整套API。
在类Unix操作系统（Unix、Linux、Mac OS X等）中，都使用Pthread作为操作系统的线程。
Windows操作系统也有其移植版pthread-win32。
文档收集自网络，仅用于个人学习Pthreads定义了一套C语言的类型、函数与常量，它以pthread.h头文件和一个线程库实现。
1.2 原理在同一个进程地址空间内执行的两个线程生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。
进程管理----生产者和消费者问题(实验报告)
计算机与信息工程系实验报告班级计算机1001班姓名李双贺时间2011年10月19日地点文理楼A504实验名称进程管理----生产者和消费者问题实验目的:（1）加深对进程概念的理解，明确进程和程序的区别。
（2）进一步认识并发执行的实质。
（3）验证用信号量机制实现进程互斥的方法。
（4）验证用信号机制实现进程同步的方法。
实验内容问题描述：考虑有一些生产者和消费者进程，生产者进程生产信息并把它们放入缓冲池中，消费者从缓冲池中取走信息。
生产者—消费者问题是相互合作的进程关系的一种抽象，如在输入时，输入进程是生产者，计算进程是消费者；而在输出时，则计算进程是生产者，打印进程是消费者。
请使用信号量机制来解决生产者—消费者问题。
互斥关系：（I）设缓冲池有n个单元。
（II）当n个单元装满时，生产者必须等待。
（III）当缓冲池空时，消费者必须等待。
参考算法：//创建生产者线程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;}//生产者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;}实验结果。
操作系统实验报告
实验一(生产者—消费者)一．实验题目生产者与消费者实验二．实验目的加深进程的概念的理解，明确进程与程序的区别，深入认识程序并发执行的实质，理解进程竞争资源的现象，互斥与同步的基本概念,掌握相关的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<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 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.open("test.txt");inFile >> n_Buffer_or_Critical;inFile.get();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;inFile.get(c);while(c!='\n'&& !inFile.eof()){inFile>>Thread_Info[n_Thread].thread_request[Thread_Info[n_Thread].n_reque st++];inFile.get(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_Critical,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,lp.c_str());}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 )(Consume),&(Thread_Info[i]),0,NULL);}wait_for_all = WaitForMultipleObjects(n_Thread,h_Thread,TRUE,-1);printf(" \n \n所有生产和消费已经完成他们的工作。
操作系统实验报告
5.然后再运行pro
显示结果如图所示：
分析与体会：
1.本次实验是关于生产者与消费者之间的互斥与同步问题—— P、V操作，实验设一个共享缓冲区，生产者与消费者互斥的使用，当一个线程使用缓冲区的时候，另一个让其等待铣刀前一个线程释放缓冲区为止。
实验成绩
备注：要求学生每次实验结束后把实验报告填好交给实验指导教师。
操
作
系
统
实
验
报
告பைடு நூலகம்
姓名：王宇菲
学号：1228524012
操作系统实验报告
2014年11月20日
学号
1228524012
姓名
王宇菲
时间
2014.11.20
专业
Java
班级
2012级
实验题目：
进程管理——生产者与消费者问题
实验目的：
通过生产者-消费者问题的模拟，加深对进程同步、共享存储器通信的理解。
实验内容与步骤：
2.试验中包含的知识点很多，包括临街资源共享问题、信号量定义、PV操作流程、进程间的通信方式（消费传递和共享内存）、进程同步和互斥、信号量机制解决进程之间的同步与互斥问题等等。加深了对于本部分内容的理解。
3.通过本实验的验证性设计，我对操作系统的P、V操作有了进一步的认识，深入的了解P、V操作的实质和其重要性、课本的理论知识进一步阐述了现实中的实际问题。
实验内容：
以生产者/消费者模型为根据，在linux系统环境下，使用VI编辑器创建product.c文件，进而模拟生产者和消费者，实现进程（线程）的同步与互斥。
实验步骤：
计算机操作系统实验-生产者和消费者
重庆交通大学综合性设计性实验报告班级：软件专业 2010 级一班姓名：李佳奇实验项目名称：生产者与消费者实验项目性质：操作系统多任务实验所属课程：计算机操作系统实验室(中心)：语音大楼 8 楼 801指导教师：米波实验完成时间： 2012 年 11 月 23 日一、实验目的1、通过实验来模拟生产者与消费者，来深入了解什么事操作系统的进程，以及进程有些什么特性。
2、了解进程间是如何做到同步的，进程间是如何做到通信的。
3、通过实验来了解进程之间同步和通信机制。
二、实验内容及要求做一个能够能直观地体现多个进程之间通过临界区进行数据的访问修改，体现出生产者和消费者关系，通过信号量进行控制。
三、实验设备PC机，windows7，eclipse。
四、设计方案㈠设计主要思想(1).要模拟多线程并发，则首先需要可视化地体现进程的运行，这样我们才能看到效果，所以可以通过进度条的长度表示生产者的生产过程和消费者的消费过程，而临界缓冲区则定义一个自定义的栈。
(2).分别定义一个生产者和两个消费者，这三个进程是完全独立的，生产者不断的向缓冲区放货物，当缓冲区满了的时候，则阻塞自己，直到消费者取走了一个货物后，将通知生产者将其唤醒。
(3).消费者不断的从缓冲区里取数据，当缓冲区为空时，则阻塞自己，直到生产者将一个货物放到缓冲区时，通知消费者，将消费着唤醒，消费者重新开始消费。
㈡设计的主要步骤(1).创建一个自定义的栈类StackBuffer，在压栈和出栈时实现同步互斥，在压栈的时候先判断堆栈是否已满，若满，则使压栈线程阻塞，否则压栈。
在出栈的时候先判断是否栈为空，若空，则将出栈线程阻塞。
核心代码：public synchronized void push(JLabel product){while(isFull()){try{this.wait();} catch (InterruptedException e){e.printStackTrace();}}this.notifyAll();productbuffer[sip++].setVisible(true);}public synchronized JLabel pop(){while(isEmpty()){try{this.wait();} catch (InterruptedException e){e.printStackTrace();}}this.notifyAll();productbuffer[--sip].setVisible(false);return productbuffer[sip];}(2).创建一个customer类继承JProgressBar类，接口Runnable，并且拥有一个StackBuffer类，在run（）方法中实现在不断向StackBuffer类对象中出栈。
生产者消费者实验报告.doc
生产者消费者实验报告实验二.生产者与消费者进程实验报告实验目的：利用Windows提供的API函数，编写程序，解决生产者与消费者问题，实现进程的互斥与同步。
实验内容与步骤：1.进程的互斥与同步。
编写一段程序，模拟生产者和消费者线程，实现进程的互斥与同步。
2.利用VC++6.0实现上述程序设计和调试操作，对于生产者和消费者线程操作的成功与否提供一定的提示框。
3.通过阅读和分析实验程序，熟悉进程的互斥与同步的概念。
程序设计思路：关于这个生产者与消费者进程，我主要设计了两个线程，一个生产者线程，一个消费者线程。
整个进程随着这两个线程的创建，运行，终止而进行。
在程序的开始，首先我创建了一个结构struct，它包括的基本数据有：生产物品缓冲区（用队列来表示），一个标志缓冲区空间多少的信号量m_S_Empty，一个标志缓冲区已有物品多少的信号量m_S_Full，一个互斥信号量m_M_Mutex防止生产者与消费者同时访问缓冲区间，一个判断生产者是否要结束生产的bool类型标志producerfinished，若为true，则两个线程都终止。
进入主程序以后，首先对这些struct中的基本数据进行一个个赋值，然后创建生产者与消费者两个线程，等待两个线程都结束时，关闭进程。
要知道在main 主函数中两个线程的创建语句就是对两个线程各自进入函数的运行，生产者函数中通过一个for循环，可以控制生产者进行多次生产，不是生产一次就结束了。
消费者函数中通过一个while循环，当生产者没有结束生产时可以控制消费者进行多次消费，不是消费一次就不会再来消费了，除非生产者已结束生产，即producerfinished的值变为true。
实验主要程序及注释：#include "stdafx.h"#include #include #include #include using namespace std;DWORD WINAPI Consumer(void*);//声明消费者函数DWORD WINAPI Producer(void*);//声明生产者函数#define N 10//定义缓冲区数量/*数据结构的定义*/struct MyData{HANDLE m_S_Empty;// 生产者SemaphoreHANDLE m_S_Full; // 消费者SemaphoreHANDLE m_M_Mutex;//互斥信号量queue food; //定义共享缓冲区bool producerfinished;//标志着生产者是否结束生产};int j=0;//只是为了输出方便观察线程执行次数int main(){ /*对各个信号量赋值*/MyData mydata;//创建一个MyData数据类型的实体mydatamydata.m_M_Mutex = CreateMutex(NULL, false, NULL);//"false"表示刚刚创建的这个信号量不属于®¨²任何线程mydata.m_S_Empty = CreateSemaphore(NULL, N, N, NULL);//初始计数为N mydata.m_S_Full = CreateSemaphore(NULL, 0, N, NULL);//初始计数为0mydata.producerfinished=false;//-利用Windows提供的API 函数，编写程序，解决生产者与消费者问题，实现进程的互斥与同步。
操作系统实验报告三大问题之生产者与消费者问题
计算机操作系统实验报告题目三大经典问题之生产者与消费者问题一、课程设计的性质与任务1、加深对并发协作进程同步与互斥概念的理解。
通过编写程序实现进程同步和互斥，使学生掌握有关进程（线程）同步与互斥的原理，以及解决进程（线程）同步和互斥的算法，从而进一步巩固进程（线程）同步和互斥等有关的内容。
2、掌握进程和线程的概念，进程（线程）的控制原语或系统调用的使用。
3、了解Windows2000/XP中多线程的并发执行机制，线程间的同步和互斥。
学习使用Windows2000/XP中基本的同步对象，掌握相应的API函数。
4、培养学生能够独立进行知识综合，独立开发较大程序的能力。
5、培养提高学生软件开发能力和软件的调试技术。
6、培养学生开发大型程序的方法和相互合作的精神。
7、培养学生的创新意识。
8、培养学生的算法设计和算法分析能力。
9、培养学生对问题进行文字论述和文字表达的能力。
二、课程设计的内容及其要求在Windows?XP、Windows?2000等操作系统下，使用的VC、VB、Java或C等编程语言，采用进程（线程）同步和互斥的技术编写程序实现生产者消费者问题或哲学家进餐问题或读者-写者问题或自己设计一个简单进程（线程）同步和互斥的实际问题。
要求：（1）经调试后程序能够正常运行。
（2）采用多进程或多线程方式运行，体现了进程（线程）同步互斥的关系。
（3）程序界面美观。
三、实验原理本实验要求利用PV操作实现解决生产者——消费者问题中的同步问题。
此问题描述的是一群生产者进程在生产产品并将这些产品提供给消费者进程去消费，在两者之间设置了一个具有n个缓冲区的缓冲池，生产者进程将它所生产的产品放入一个缓冲区，消费者进程可从缓冲区中取走产品去消费，但它们之间必须保持同步，即不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满且尚未取出的缓冲区中投放产品，并且生产者消费者互斥使用缓冲区。
四、实验原理图五、算法实现（1）有一个生产者线程ProduceThread，有1个消费者进程CustomerThread；缓冲区为shareList。
生产消费系统实验报告(3篇)
第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）互斥：通过公用信号量实现生产者和消费者对环形缓冲区的互斥访问，防止了同时操作缓冲区的问题。
进程同步(生产者与消费者)
软件学院操作系统实验报告专业：软件工程班级：RB软工互152学号：201560160226学生姓名：王泽华指导教师：韩新超实验二: 进程同步（生产者与消费者）一．实验目的1）理解进程竞争资源的现象，进而理解进程的同步于互斥；2）掌握基本的互斥与同步算法，进一步理解“生产者—消费者”模型；3）通过对“生产者—消费者”问题编程实现，了解进程创建、同步信号量、互斥信号量、临界区的创建和使用，初步了解并发程序设计方法；4）进一步理解P、V原语和信号量在线程互斥和同步机制中的运用。
二．实验属性该实验为设计性实验。
三．实验仪器设备及器材普通PC386以上微机四．实验理论基础1、该实验中使用到相关的windows API 函数：1）create Thread 建立新的线程；2）create Mutex创建一个互斥体；3）create Semaphore 创建一个新的信号量；4）release Mutex释放由线程拥有的一个互斥体；5）release Semaphore 对指定的信号量增加指定的值；6）wait for Single Object 用来检测handle时间的信号状态；7）wait for Multiple Objects true 即等待所有信号量有效再往下执行，false 当其中一个信号量有效时向下执行；8）Close Handle 关闭一个内核对象。
2、数据结构用实验一中的进程就绪队列，并在此基础上进行调度，如果队列排序与算法要求不一致则编写一个排序函数。
3、进程调度算法：选择一种进程调度算法实现。
4、主界面设计：在实验一的界面上增加一个进程调度按钮、被调进程的PCB显示。
5、功能测试：从显示出的就绪队列状态和被调进程的PCB，查看操作的正确与否。
五.实验步骤（2）结果分析：①在每个过程中先做P(mutex)，后做V(mutex)，二者要成对出现。
夹在二者中间的代码段就是该进程的临界区。
②对同步信号量full和empty的P，V操作同样必须成对出现，但它们分别位于不同的程序中。
操作系统之进程(生产者---消费者)实验报告
操作系统实验报告——生产者和消费者问题姓名：学号：班级：一、实验内容1、模拟操作系统中进程同步和互斥；2、实现生产者和消费者问题的算法实现；二、实验目的1、熟悉临界资源、信号量及PV操作的定义与物理意义；2、了解进程通信的方法；3、掌握进程互斥与进程同步的相关知识；4、掌握用信号量机制解决进程之间的同步与互斥问题；5、实现生产者－消费者问题，深刻理解进程同步问题；三、实验题目在Windows操作系统下用C语言实现经典同步问题：生产者—消费者，具体要求如下：(1)一个大小为10的缓冲区，初始状态为空。
(2)2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。
页脚内容1(3)2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。
四、思想本实验的主要目的是模拟操作系统中进程同步和互斥。
在系统进程并发执行异步推进的过程中，由于资源共享和进程间合作而造成进程间相互制约。
进程间的相互制约有两种不同的方式。
（1）间接制约。
这是由于多个进程共享同一资源（如CPU、共享输入/输出设备）而引起的，即共享资源的多个进程因系统协调使用资源而相互制约。
（2）直接制约。
只是由于进程合作中各个进程为完成同一任务而造成的，即并发进程各自的执行结果互为对方的执行条件，从而限制各个进程的执行速度。
生产者和消费者是经典的进程同步问题，在这个问题中，生产者不断的向缓冲区中写入数据，而消费者则从缓冲区中读取数据。
生产者进程和消费者对缓冲区的操作是互斥，即当前只能有一个进程对这个缓冲区进行操作，生产者进入操作缓冲区之前，先要看缓冲区是否已满，如果缓冲区已满，则它必须等待消费者进程将数据取出才能写入数据，同样的，消费者进程从缓冲区读取数据之前，也要判断缓冲区是否为空，如果为空，则必须等待生产者进程写入数据才能读取数据。
在本实验中，进程之间要进行通信来操作同一缓冲区。
操作系统实验报告经典生产者—消费者问题范文大全[修改版]
![操作系统实验报告经典生产者—消费者问题范文大全[修改版]](https://img.taocdn.com/s3/m/81367c57d1f34693dbef3ed3.png)
第一篇：操作系统实验报告经典生产者—消费者问题实验二经典的生产者—消费者问题一、目的实现对经典的生产者—消费者问题的模拟，以便更好的理解经典进程同步问题。
二、实验内容及要求编制生产者—消费者算法，模拟一个生产者、一个消费者，共享一个缓冲池的情形。
1、实现对经典的生产者—消费者问题的模拟，以便更好的理解此经典进程同步问题。
生产者－消费者问题是典型的PV 操作问题，假设系统中有一个比较大的缓冲池，生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中，而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。
缓冲池被占用时，任何进程都不能访问。
2、每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。
在这种情况下，生产者消费者进程同步，因为只有通过互通消息才知道是否能存入产品或者取走产品。
他们之间也存在互斥，即生产者消费者必须互斥访问缓冲池，即不能有两个以上的进程同时进行。
三、生产者和消费者原理分析在同一个进程地址空间内执行两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品，然后释放缓冲区。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放一个空缓冲区。
当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻挡，直到新的物品被生产出来。
四、生产者与消费者功能描述：生产者功能描述：在同一个进程地址空间内执行两个线程。
生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。
当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。
消费者功能描述：消费者线程从缓冲区获得物品，然后释放缓冲区，当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。
五、实验环境操作系统环境：Windows 系统。
编程语言：C#。
生产者和消费者问题实验报告
格式： 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簪巷
操作系统实验报告生产者消费者问题
课程设计说明书山东科技大学2014年 1 月 1 日课程设计任务书一、课程设计题目：生产者消费者问题二、课程设计主要参考资料（1）《计算机操作系统》（修订版）．汤子瀛．西安电子科技大学出版社。
（2）《数据结构》严蔚敏清华大学出版社（3）《操作系统概念》第六版三、课程设计应解决的主要问题：（1）了解信号量的使用（2）理解生产者消费者问题模型（3）掌握真确使用同步机制的方法（4）实现生产者消费者进程的互斥与同步四、课程设计相关附件（如：图纸、软件等）：程序源代码五、任务发出日期： 2013-12-1 课程设计完成日期： 2014-12-25指导教师签字：系主任签字：指导教师对课程设计的评语成绩：指导教师签字：年月日生产者消费者问题一、设计目的1、了解信号量的使用2、加深对信号量机制的理解3、通过研究Linux 的进程机制和信号量实现生产者消费者问题的并发控制.4、掌握基本的同步互斥算法，理解生产者与消费者模型5、了解多线程（多进程）的并发执行机制，线程（进程）间的同步与互斥二、设计要求1、理解生产者与消费者问题模型，掌握解决问题的算法思想2、掌握正确使用同步机制的方法3、每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费者线程的标识符.4、生产者和消费者各有两个以上.5、多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码.三、设计说明（含系统框图和（或）主要算法的流程图）生产者流程图消费者流程图有n个生产者和m个消费者，连接在具有k个单位缓冲区的有界环转缓冲上，故又称有界缓冲问题。
其中Pi 和Cj都是并发进程，只要缓冲区未满，生产者进程Pi所生产的产品就可投入缓冲区；类似地，只要缓冲区非空，消费者进程Cj就可以从缓冲区取走并消耗产品。
生产者——消费者问题是典型的进程同步问题，这些进程必须按照一定的生产率和消费率来访问共享缓冲区，用P、V操作解决生产者和消费者共享单缓冲区的问题，可设置两个信号量empty和full，其初值分别为1和0，empty指示能否向缓冲区放入产品，full 指示能否从缓冲区取出产品。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统实验报告——生产者和消费者问题姓名：学号：班级：一、实验内容1、模拟操作系统中进程同步和互斥；2、实现生产者和消费者问题的算法实现；二、实验目的1、熟悉临界资源、信号量及PV操作的定义与物理意义；2、了解进程通信的方法；3、掌握进程互斥与进程同步的相关知识；4、掌握用信号量机制解决进程之间的同步与互斥问题；5、实现生产者－消费者问题，深刻理解进程同步问题；三、实验题目在Windows操作系统下用C语言实现经典同步问题：生产者—消费者，具体要求如下：(1)一个大小为10的缓冲区，初始状态为空。
(2)2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。
(3)2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。
四、思想本实验的主要目的是模拟操作系统中进程同步和互斥。
在系统进程并发执行异步推进的过程中，由于资源共享和进程间合作而造成进程间相互制约。
进程间的相互制约有两种不同的方式。
（1）间接制约。
这是由于多个进程共享同一资源（如CPU、共享输入/输出设备）而引起的，即共享资源的多个进程因系统协调使用资源而相互制约。
（2）直接制约。
只是由于进程合作中各个进程为完成同一任务而造成的，即并发进程各自的执行结果互为对方的执行条件，从而限制各个进程的执行速度。
生产者和消费者是经典的进程同步问题，在这个问题中，生产者不断的向缓冲区中写入数据，而消费者则从缓冲区中读取数据。
生产者进程和消费者对缓冲区的操作是互斥，即当前只能有一个进程对这个缓冲区进行操作，生产者进入操作缓冲区之前，先要看缓冲区是否已满，如果缓冲区已满，则它必须等待消费者进程将数据取出才能写入数据，同样的，消费者进程从缓冲区读取数据之前，也要判断缓冲区是否为空，如果为空，则必须等待生产者进程写入数据才能读取数据。
在本实验中，进程之间要进行通信来操作同一缓冲区。
一般来说，进程间的通信根据通信内容可以划分为两种：即控制信息的传送与大批量数据传送。
有时，也把进程间控制在本实验中，进程之间要进行通信来操作同一缓冲区。
一般来说，进程间的通信根据通信内容可以划分为两种：即控制信息的传送与大批量数据传送。
有时，也把进程间控制信息的交换称为低级通信，而把进程间大批量数据的交换称为高级通信。
目前，计算机系统中用得比较普遍的高级通信机制可分为3大类：共享存储器系统、消息传递系统及管道通信系统。
•共享存储器系统共享存储器系统为了传送大量数据，在存储器中划出一块共享存储区，诸进程可通过对共享存储区进行读数据或写数据以实现通信。
进程在通信之前，向系统申请共享存储区中的一个分区，并为它指定一个分区关键字。
信息的交换称为低级通信，而把进程间大批量数据的交换称为高级通信。
•消息传递系统在消息传递系统中，进程间的数据交换以消息为单位，在计算机网络中被称为报文。
消息传递系统的实现方式又可以分为以下两种：(1)直接通信方式发送进程可将消息直接发送给接收进程，即将消息挂在接收进程的消息缓冲队列上，而接收进程可从自己的消息缓冲队列中取得消息。
(2)间接通信方式发送进程将消息发送到指定的信箱中，而接收进程从信箱中取得消息。
这种通信方式又称信箱通信方式，被广泛地应用于计算机网络中。
相应地，该消息传递系统被称为电子邮件系统。
•管道通信系统向管道提供输入的发送进程，以字符流方式将大量的数据送入管道，而接收进程从管道中接收数据。
由于发送进程和接收进程是利用管道进行通信的，故称为管道通信。
为了协调发送和接收双方的通信，管道通信机制必须提供以下3方面的协调功能。
（1）互斥当一个进程正在对pipe文件进行读或写操作时，另一个进程必须等待。
（2）同步当写进程把一定数量的数据写入pipe文件后，便阻塞等待，直到读进程取走数据后，再把写进程唤醒。
（3）确认对方是否存在只有确定对方已存在时，才能进行管道通信，否则会造成因对方不存在而无限制地等待。
在这个问题当中，我们采用信号量机制进行进程之间的通信，设置两个信号量，空的信号量和满的信号量。
在Windows系统中，一个或多个信号量构成一个信号量集合。
使用信号量机制可以实现进程之间的同步和互斥，允许并发进程一次对一组信号量进行相同或不同的操作。
每个P、V操作不限于减1或加1，而是可以加减任何整数。
在进程终止时，系统可根据需要自动消除所有被进程操作过的信号量的影响。
1．缓冲区采用循环队列表示，利用头、尾指针来存放、读取数据，以及判断队列是否为空。
缓冲区中数组大小为10；2．利用随机函数rand()得到A～Z的一个随机字符，作为生产者每次生产的数据，存放到缓冲区中；3. 使用shmget()系统调用实现共享主存段的创建， shmget()返回共享内存区的ID。
对于已经申请到的共享段，进程需把它附加到自己的虚拟空间中才能对其进行读写。
4.信号量的建立采用semget()函数，同时建立信号量的数量。
在信号量建立后，调用semctl()对信号量进行初始化，例如本实习中，可以建立两个信号量SEM_EMPTY、SEM_FULL，初始化时设置SEM_EMPTY 为10，SEM_FULL为0。
使用操作信号的函数semop()做排除式操作，使用这个函数防止对共享内存的同时操作。
对共享内存操作完毕后采用shmctl()函数撤销共享内存段。
5.使用循环，创建2个生产者以及2个消费者，采用函数fork()创建一个新的进程。
6．一个进程的一次操作完成后，采用函数fflush()刷新缓冲区。
7．程序最后使用semctl()函数释放内存。
模拟程序的程序流程图如下所示：1.主程序流程图：2.生产者进程流程图3.消费者进程流程图4.P操作流程图5.V操作流程图五、实现代码为：// exet5.cpp#include "stdafx.h"#include <stdio.h>#include <stdlib.h>#define mSIZE 3#define pSIZE 20static int memery[mSIZE] = {0};static int process[pSIZE] = {0};//static int process[pSIZE] = {2,3,2,1,5,2,4,5,3,2,5,2};//static int process[pSIZE] = {7,10,1,2,10,3,10,4,2,3,10,3,2,1,2,10,1,7,10,1}; void build();void LRU();int main(intargc, char *argv[]){printf("Random sequence is as follows:\n");build();printf("\nInvoking LRU Algorithn: \n");LRU();return 0;}void build(){int i = 0;for(i=0; i<pSIZE; i++){process[i] = (int)(10.0*rand()/(RAND_MAX));printf("%d ",process[i]);}printf("\n");}void LRU(){int flag[mSIZE] = {0};int i = 0, j = 0;int m = -1, n = -1;int max = -1,maxflag = 0;int count = 0;for(i = 0; i<pSIZE; i++){//Find the first free Physical Blockfor(j=0; j<mSIZE; j++){if(memery[j] == 0){m = j;break;}}//Find if there are same processes for(j = 0; j <mSIZE; j++){if(memery[j] == process[i]){n = j;}}//Find free PBfor(j = 0; j <mSIZE;j++){if(flag[j]>maxflag){maxflag = flag[j];max = j;}}if(n == -1) // Find no same process {if(m != -1) // find free PB{memery[m] = process[i];flag[m] = 0;for(j = 0;j <= m; j++){flag[j]++;}m = -1;}else //NO find free PB{memery[max] = process[i];flag[max] = 0;for(j = 0;j <mSIZE; j++){flag[j]++;}max = -1;maxflag = 0;count++;}}else // Find same process{memery[n] = process[i];flag[n] = 0;if(m != -1) //find free PB{flag[m] = 0;}for(j = 0;j <mSIZE; j++){flag[j]++;}max = -1;maxflag = 0;n = -1;}for(j = 0 ;j <mSIZE; j++){printf("%d ",memery[j]);}printf("\n");}printf("\nThe times of page conversion is: %d\n",count);下载可编辑}六、实验总结及思考1、本次实验是关于生产者与消费者之间互斥和同步的问题。
问题的是指是P、V操作，实验设一个共享缓冲区，生产者和消费者互斥的使用，当一个线程使用缓冲区的时候，另一个让其等待直到前一个线程释放缓冲区为止。
2、实验中包含的知识点很多，包括临界区资源共享问题、信号量定义、PV操作流程、进程间的通信方式（消息传递和共享内存）、进程同步和互斥、信号量机制解决进程之间的同步与互斥问题等等。
加深了对于本部分内容的理解通过本实验设计，我们对操作系统的P、V进一步的认识，深入的了解P、V操作的实质和其重要性。
课本的理论知识进一步阐述了现实中的实际问题。
.专业.整理.。