第一篇：实验报告五 生产者和消费者问题
实验报告五
——生产者和消费者问题
姓名：丛菲 学号：20100830205 班级：信息安全二班
一、实习内容
• •
1、模拟操作系统中进程同步和互斥
2、实现生产者和消费者问题的算法实现
二、实习目的
• • • • •
1、熟悉临界资源、信号量及PV操作的定义与物理意义
2、了解进程通信的方法
3、掌握进程互斥与进程同步的相关知识
4、掌握用信号量机制解决进程之间的同步与互斥问题
5、实现生产者－消费者问题，深刻理解进程同步问题
三、实习题目
• 在Linux操作系统下用C实现经典同步问题：生产者—消费者，具体要求如下：
(1)一个大小为10的缓冲区，初始状态为空。
(2)2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。
(3)2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。• 提示
本实验的主要目的是模拟操作系统中进程同步和互斥。在系统进程并发执行异步推进的过程中，由于资源共享和进程间合作而造成进程间相互制约。进程间的相互制约有两种不同的方式。
（1）间接制约。这是由于多个进程共享同一资源（如CPU、共享输入/输出设备）而引起的，即共享资源的多个进程因系统协调使用资源而相互制约。
（2）直接制约。只是由于进程合作中各个进程为完成同一任务而造成的，即并发进程各自的执行结果互为对方的执行条件，从而限制各个进程的执行速度。
生产者和消费者是经典的进程同步问题，在这个问题中，生产者不断的向缓冲区中写入数据，而消费者则从缓冲区中读取数据。生产者进程和消费者对缓冲区的操作是互斥，即当前只能有一个进程对这个缓冲区进行操作，生产者进入操作缓冲区之前，先要看缓冲区是否已满，如果缓冲区已满，则它必须等待消费者进程将数据取出才能写入数据，同样的，消费者进程从缓冲区读取数据之前，也要判断缓冲区是否为空，如果为空，则必须等待生产者进程写入数据才能读取数据。
在本实验中，进程之间要进行通信来操作同一缓冲区。一般来说，进程间的通信根据通信内容可以划分为两种：即控制信息的传送与大批量数据传送。有时，也把进程间控制在本实验中，进程之间要进行通信来操作同一缓冲区。一般来说，进程间的通信根据通信内容可以划分为两种：即控制信息的传送与大批量数据传送。有时，也把进程间控制信息的交换称为低级通信，而把进程间大批量数据的交换称为高级通信。
目前，计算机系统中用得比较普遍的高级通信机制可分为3大类：共享存储器系统、消息传递系统及管道通信系统。
• 共享存储器系统
共享存储器系统为了传送大量数据，在存储器中划出一块共享存储区，诸进程可通过对共享存储区进行读数据或写数据以实现通信。进程在通信之前，向系统申请共享存储区中的一个分区，并为它指定一个分区关键字。信息的交换称为低级通信，而把进程间大批量数据的交换称为高级通信。
目前，计算机系统中用得比较普遍的高级通信机制可分为3大类：共享存储器系统、消息传递系统及管道通信系统。
• 消息传递系统
在消息传递系统中，进程间的数据交换以消息为单位，在计算机网络中被称为报文。消息传递系统的实现方式又可以分为以下两种：(1)直接通信方式
发送进程可将消息直接发送给接收进程，即将消息挂在接收进程的消息缓冲队列上，而接收进程可从自己的消息缓冲队列中取得消息。(2)间接通信方式
发送进程将消息发送到指定的信箱中，而接收进程从信箱中取得消息。这种通信方式又称信箱通信方式，被广泛地应用于计算机网络中。相应地，该消息传递系统被称为电子邮件系统。
• 管道通信系统
向管道提供输入的发送进程，以字符流方式将大量的数据送入管道，而接收进程从管道中接收数据。由于发送进程和接收进程是利用管道进行通信的，故称为管道通信。为了协调发送和接收双方的通信，管道通信机制必须提供以下3方面的协调功能。（1）互斥
当一个进程正在对pipe文件进行读或写操作时，另一个进程必须等待。（2）同步
当写进程把一定数量的数据写入pipe文件后，便阻塞等待，直到读进程取走数据后，再把写进程唤醒。
（3）确认对方是否存在 只有确定对方已存在时，才能进行管道通信，否则会造成因对方不存在而无限制地等待。在这个问题当中，我们采用信号量机制进行进程之间的通信，设置两个信号量，空的信号量和满的信号量。在Linux系统中，一个或多个信号量构成一个信号量集合。使用信号量机制可以实现进程之间的同步和互斥，允许并发进程一次对一组信号量进行相同或不同的操作。每个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
= {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(){ inti = 0;for(i=0;i
{ process[i] =(int)(10.0*rand()/(RAND_MAX));printf(“%d ”,process[i]);
} printf(“n”);}
void LRU(){ int flag[mSIZE] = {0};inti = 0, j = 0;int m =-1, n =-1;int max =-1,maxflag = 0;int count = 0;for(i = 0;i
//Find the first free Physical Block
for(j=0;j { if(memery[j] == 0) { m = j;break; } } //Find if there are same processes for(j = 0;j { if(memery[j] == process[i]) { n = j; } } //Find free PB for(j = 0;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 { 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 { flag[j]++; } max =-1;maxflag = 0; n =-1; } for(j = 0;j { printf(“%d ”,memery[j]); } printf(“n”);} printf(“nThe is: %dn”,count);} times of page conversion 五、在虚拟机上的具体操作及结果 执行exe5.c文件 选择ApplicationsAcecessoriesTerminal,执行文件： 依次预处理编译汇编连接执行用文件，编译通过之后-o执行。报错！！错误显示为很多头文件没有预定义。连续查找之后得知原因是链接不上pthread库 在执行命令后面加上-pthread，即新命令格式为：gcc-oexe5exe5.c–lpthread，重新执行后的结果显示如下截图： 其中1表示缓冲区被生产者producer1或者二producer2写入了Item，0表示没有写入数据或者被消费者consumer1或者consumer2消耗掉 六、实验总结及思考 1、本次实验是关于生产者与消费者之间互斥和同步的问题。问题的是指是P、V操作，实验设一个共享缓冲区，生产者和消费者互斥的使用，当一个线程使用缓冲区的时候，另一个让其等待直到前一个线程释放缓冲区为止。 2、实验中包含的知识点很多，包括临界区资源共享问题、信号量定义、PV操作流程、进程间的通信方式（消息传递和共享内存）、进程同步和互斥、信号量机制解决进程之间的同步与互斥问题等等。加深了对于本部分内容的理解 通过本实验设计，我们对操作系统的P、V进一步的认识，深入的了解P、V操作的实质和其重要性。课本的理论知识进一步阐述了现实中的实际问题。 实 验 二 经 典 的 生 产 者 — 消 费 者 问 题 一、目的 实现对经典的生产者—消费者问题的模拟，以便更好的理解经典进程同步问题。 二、实验内容及要求 编制生产者—消费者算法，模拟一个生产者、一个消费者，共享一个缓冲池的情形。 1、实现对经典的生产者—消费者问题的模拟，以便更好的理解此经典进程同步问题。生产者－ 消费者问题是典型的 PV 操作问题，假设系统中有一个比较大的缓冲池，生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中，而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产 品。缓冲池被占用时，任何进程都不能访问。 2、每一个生产者都要把自己生产的产品放入缓冲池，每个消费者从缓冲池中取走产品消费。在这种情况下，生产者消费者进程同步，因为只有通过互通消息才知道是否能存入产品或者取走产品。他们之间也存在互斥，即生产者消费者必须互斥访问缓冲池，即不能有两个以上的进程同时进行。 三、生产者和消费者原理分析 在同一个进程地址空间内执行两个线程。 生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。 消费者线程从缓冲区中获得物品，然后释放缓冲区。 当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放一个空缓冲区。 当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻挡，直到新的物品被生产出来。 四、生产者与消费者功能描述： 生产者功能描述：在同一个进程地址空间内执行两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。 消费者功能描述：消费者线程从缓冲区获得物品，然后释放缓冲区，当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 五、实验环境 操作系统环境： Windows 系统。编程语言： C#。 六、生产者与消费者的思路和设计 1、程序流程图 (1)生产者 开 始 生产产品 Wait empty ≤ 0 Y N Wait 缓冲区内已满，已无 可用缓冲区 N Mutex=1 Y 缓冲区正被其他 程占用 进 存入缓冲区 empty = empty-1 Signal Signal(full)结 束 (2)消费者 开 始 Wait(full)消费请求 full ≤ 0 Y N Wait 缓冲区内产品已空，不能进行消费 N Mutex=1 Y 消 费 缓冲区正被其他 程占用 进 full = full-1 Signal Signal 结 束 2、主要程序代码 // 初始化变量 private void Form1_Load(object sender, EventArgs e){ mutex = 1;// 互斥信号量 full = 0;// 缓冲池中满缓冲区的数量 empty = 5;// 缓冲池中空缓冲区的数量 count1 = 0;// 生产的产品数目 i = 0;= “1”;= “0”;= “5”;} // 消费者从缓冲区中消费一个产品 private void consumer_Click(object sender, EventArgs e){ if(full > 0){ // 消费者已进入互斥临界区 if(mutex == 1)// 申请进入临界区 { mutex = 0;// 消费者已进入互斥临界区 = “0”;= true;// 启动消费者消费缓冲区产品 } else {(“ 缓冲区被占用，请等待。。 ”, “ 信息提 ”;} } else {(“ 缓冲区为空，不能消费!”, “ 信息提示 ”,;} } // 生产者向缓冲区中存入一个产品 private void producer_Click(object sender, EventArgs e){ count1 = count1 + if(empty > 0){ 1; // // 生产一个产品 有缓冲区可放产品 if(mutex == 1){ // 申请进入临界区 mutex = 0; // 生产者已进入临界区 = “0”; ();// 启动生产者将产品放入缓冲区 } else { // 不能进入临界区 count1 = count1-1;(“ 缓冲区被占用，请等待。。 ”, “ 信息提示 ”,;} } else {(“ 缓冲区已满!”, “ 信息提示 ”,;// 无缓冲区可放产品 count1 = count1-1;} } // 生产者 private void timer1_Tick_1(object sender, EventArgs e){ if(bool1){ switch(count1){ case 1: = true;break;case 2: = true;break;case 3: = true;break;case 4: = true;break;case 5: = true;break;} = “ 生产者进程占用缓冲区，请等待。。 ”;bool1 = false;} else { switch(count1){ case 1: = false;break;case 2: = false;break;case 3: = false;break;case 4: = false;break;case 5: = false;break;} = “ 生产者进程占用缓冲区，请等待。。 ”;bool1 = true;} i = i + 1;if(i == 5) { // 循环缓冲区，首尾相接 i = 0;= false;mutex = 1;= “1”;switch(count1){ case 1: = true;break;case 2: = true;break;case 3: = true;break;case 4: = true;break;case 5: = true;break;} full = full + 1;=();empty = empty-1;=();= “ 生产结束!”;} } // 消费者 private void timer_consumer_Tick(object sender, EventArgs e){ if(bool1){ switch(count1){ case 1: = true;break;case 2: = true;break;case 3: = true;break;case 4: = true;break;case 5: = true;break;} = “ 消费者进程占用缓冲区，请等待。。 ”;bool1 =false;} else{ switch(count1){ case 1: = false;break;case 2: = false;break;case 3: = false;break;case 4: = false;break;case 5: = false;break;} = “ 消费者进程占用缓冲区，请等待。。 ”;bool1= true;} i = i + 1;if(i==5){ i = 0;= false;mutex = 1;= “1”;switch(count1){ case 1: = false;break;case 2: = false;break;case 3: = false;break;case 4: = false;break;case 5: = false;break;} count1 = count1-1;full = full-1;=();empty = empty+1;=();=“ 消费结束！ ”;} 3、运行界面和运行结果 一般情况下，点一次生产者按纽，mutex 由 1 变为 0，缓冲区呈现闪烁状态（表示正在存储），此时不可以再进行缓冲区操作，否则将显示“生产者进程正在占用缓冲区，请等待”。闪烁约秒后，mutex 由 0 变为 1，闪烁停止，表示存储过程结束；点一次消费者按纽，mutex 由 1 变为 0，缓冲区呈现闪烁状态（表示正在消费），此时不可以再进行缓冲区操作，否则将显示“消费者进程正在占用缓 冲区，请等待”。闪烁约秒后，mutex 由 0 变为 1，闪烁停止，表示消费过程结束。缓冲池满后，若再点生产者按纽，会给出信息提示： “缓冲区已满!”。 缓冲池空后，若再点消费者按纽，也会给出信息提示： “缓冲区为空，不能消费!”。 在存储状态或消费状态（闪烁状态），无论是点生产者按纽还是消费者按纽都会给出“缓冲区被占用，请等待。”信息提示。 七、心得体会 本次实验是关于生产者与消费者之间互斥和同步的问题。问题的是指是 P、V 操作，实验设一个共享缓冲区，生产者和消费者互斥的使用，当一个线程使用缓冲区的时候，另一个让其等待直到前一 个线程释放缓冲区为止。 生产者与消费者是一个与现实有关的经验问题，通过此原理举一反三可以解决其他类似的问题。 通过本实验设计，我们对操作系统的 P、V 进一步的认识，深入的了解 P、V 操作的实质和其重 要性。课本的理论知识进一步阐述了现实中的实际问题。 实验中，我们小组分工合作，共同学习，虽然在实验中遇到了一些问题，但在老师和同学的细心指导和热心帮助下解决了。同时，了解到团队精神的重要性，也为以后的学习和工作打下了坚实的基础，同时积累了宝贵的经验。 南京信息工程大学 实验（实习）报告 实验（实习）名称 生产者-消费者问题的模拟实现 实验（实习）日期 2014.11.30 得分 指导教师 陈遥 系 计算机 专业 计科 年级 12级 班次 2 姓名 唐薇 学号 20122308061 一、实验目的 本实验的目的是通过编写和调试一个解决生产者–消费者问题的简单模拟程序，进一步深入理解课堂教学中讲授的进程同步问题，以及用于解决同步问题的信号量机制的基本思想，即通过研究进程同步和信号量机制实现生产者消费者问题的并发控制，以便阶段性地巩固学习成果。 二、实验内容 （1）概述 说明:有界缓冲区内设有20个存储单元,放入/取出的数据项设定为1-20这20个整型数。 编制程序模拟解决生产者-消费者同步问题。具体设计要求:(1)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费线程的标识符。(2)生产者和消费者各有两个以上。(3)多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码。（2）设计原理 通过一个有界缓冲区把生产者和消费者联系起来。假定生产者和消费者的优先级是相同的，只要缓冲区未满，生产者就可以生产产品并将产品送入缓冲区。类似地，只要缓冲区未空，消费者就可以从缓冲区中取走产品。应该禁止生产者向满的缓冲区送入产品，同时也应该禁止消费者从空的缓冲区中取出产品，这一机制由生产者线程和消费者线程之间的互斥关系来实现。与计算打印两进程同步关系相同，生产者和消费者两进程Producer和Consumer之间应满足下列两个同步条件： • 只有在缓冲池中至少有一个缓冲区已存入消息后，消费者才能从中提取信息，否则消费者必须等待。 • 只有缓冲池中至少有一个缓冲区是空时，生产者才能把消息放入缓冲区，否则生产者必须等待。 为了满足第一个同步条件，设置一个同步信号量full，它代表的资源是缓冲区满，它的初始值为0，它的值为n时整个缓冲池满。这个资源是消费者进程Consumer所有，Consumer进程可以申请该资源，对它施加P操作，而Consumer进程的合作进程生产者进程Producer对它施加V操作。同样为了满足第二个同步条件，设置另一个同步信号量empty，它代表的资源是缓冲空区，它的初始值为n，表示缓冲池中所有缓冲区空。信号量full表示可用缓冲区数量，信号量empty表示缓冲区数量，设置整型变量：存入指针in和取出指针out。 为解决生产者/消费者问题，应该设置两个资源信号量，其中一个表示空缓冲区的数目，用g_hFullSemaphore表示，其初始值为有界缓冲区的大小SIZE_OF_BUFFER；另一个表示缓冲区中产品的数目，用g_hEmptySemaphore表示，其初始值为0。另外，由于有界缓冲区是一个临界资源，必须互斥使用，所以还需要在设置一个互斥信号量g_hMutex，初始值为1.P原语的主要动作是： • sem（信号量）减1； • 若sem减一后仍大于或等于零，则进程继续执行； • 若sem减一后小于零，则该进程被阻塞后入与该信号相对应的队列中，然后转进程调度。V原语的操作主要动作是： • sem加1； • 若相加结果大于零，进程继续执行； ③若相加结果小于或等于零，则从该信号的等待队列中唤醒一等待进程然后再返回原进程继续执行或转进程调度。 采用的同步方法： 1）利用函数CreateMutex(NULL,FALSE,NULL)创建互斥信号量g_hMutex，表示缓冲区当前的状态，若为true时，则表示缓冲区正被别的进程使用。三个参数表示的意义分别为：指向安全属性的指针，初始化互斥对象的所有者,指向互斥对象名的指针。 2）利用函数CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1, NULL)创建缓冲区空的信号量g_hFullSemaphore，值为true时表示缓冲区已满。四个参数分别为：表示是否允许继承、设置信号机的初始计数、设置信号机的最大计数、指定信号机对象的名称（-1是因为计数从开始）。 3）利用函数CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL)创建缓冲区满的信号量g_hEmptySemaphore，该值为true时表示缓冲区为空。 程序清单 1.存储结构定义 利用信号量解决生产者消费者问题 const unsigned short SIZE_OF_BUFFER = 20;//缓冲区长度 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);//消费者线程 2.算法相关的函数 （1）创建各个互斥信号以及生产者线程和消费者线程的函数在如下主函数里面所示： 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[THREADS_COUNT];//各线程的handle DWORD producerID[PRODUCERS_COUNT];//生产者线程的标识符 DWORD consumerID[CONSUMERS_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 //生产一个产品。简单模拟了一下，仅输出新产品的ID号 void Produce(){ std::cerr << “Producing ” << ++ProductID << “ *** ”;std::cerr << “Succeed” << std::endl;}（3）把新生产的产品放入缓冲区的函数： //把新生产的产品放入缓冲区 void Append(){ std::cerr << “Appending a product *** ”;g_buffer[in] = ProductID;in =(in+1)%SIZE_OF_BUFFER;std::cerr << “Succeed” << std::endl;}（4）输出缓冲区当前的状态的代码： //输出缓冲区当前的状态 for(int i=0;i for(int i=0;i 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;}（2）消费者算法： //消费者 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;} • 运行结果分析 输入输出数据说明和分析： 该程序设置的缓冲区数据长度为20，生产者个数为3，消费者个数为1，程序启动后，生产者先进行生产，当3个生产者全部生产完之后，消费者开始从缓冲区中取出产品，当消费者取出一个后，生产者开始继续生产，当生产完3个之后，消费者开始从缓冲池中取产品，依次循环。 三、小结 通过本次试验，我对操作系统中线程，进程同步互斥等知识的应用有了更深的了解，我知道了生产者—消费者问题是很著名的同步问题，的确是既简单又复杂。 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 （操作系统课程设计） 生 产 者 和 消 费 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 者 学生姓名： 学生学号： 班 级： 0311401、02、03、04班制 二〇一三年十二月 一、课程题目分析 这个题目是生产者向消费者提供商品，消费者消耗商品，并且两组人共用同一缓冲区。生产者提供了商品之后消费者才能去取商品，消费者若不取走商品则当缓冲区用完之后生产者则不能再向缓冲区中添加新的商品。 思考问题： （1）对于生产者进程：每产生一个数据，则需去访问共用缓冲区是否有已满，未满则可以将该数据存入并通知消费者进程，否则不能。 （2）对于消费者进程：每当想去消费（取出数据）时，则需访问缓冲区是否为空，为空则不能消费（取出数据），否则可以取，并通知生产者。 （3）缓冲区是个临界资源，所有的进程对于该空间都是共享的，所以，还有互斥问题存在。 二、课程设计目的 通过实验模拟生产者与消费者之间的关系，了解并掌握他们之间的关系及原理。由此增加对进程同步问题的了解： （1）掌握基本的同步互斥算法，理解生产者与消费者模型 （2）了解windows中多线程（多进程）的并发执行机制，线程（进程）间的同步于互斥 （3）学习使用windows中基本的同步对象，掌握相应的API。 三、课程设计内容 有n个生产者和m个消费者，连接在具有k个单位缓冲区的有界环转缓冲上，湖北民族学院信息工程学院11级计算机专业操作系统课程设计 故又称有界缓冲问题。其中Pi和Cj都是并发进程，只要缓冲区未满，生产者进程Pi所生产的产品就可投入缓冲区；类似地，只要缓冲区非空，消费者进程Cj就可以从缓冲区取走并消耗产品。 四、开发环境 操作系统：Windows系统 编写语言：C++语言 五、系统分析设计 （一）算法原理 生产者——消费者问题是典型的进程同步问题，这些进程必须按照一定的生产率和消费率来访问共享缓冲区，用P、V操作解决生产者和消费者共享单缓冲区的问题，可设置两个信号量empty和full，其初值分别为1和0，empty指示能否向缓冲区放入产品，full指示能否从缓冲区取出产品。为了使其协调工作，必须使用一个信号量mutex（初值为1），以限制生产者和消费者互斥地对缓冲区进行存取，另用两个信号量empty1（初值为缓冲区大小）和full1（初值为0），以保证生产者不向已满的缓冲区中放入产品，消费者不从空缓冲区中取产品。 （二）功能描述 生产者功能描述：在同一个进程地址空间内执行两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。 消费者功能描述：消费者线程从缓冲区获得物品，然后释放缓冲区，当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 （三）算法流程图 生产者流程图： 消费者流程图： 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 总的流程图： 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 开始Int i=1，n键盘输入数字，初始化 n SeqSquare *b;b=new SeqSquare(n)；键盘输入数字，改变i的值i==0？Y退出Ncout<<“请输入正确的菜单项进行操作!”< (四)数据结构及部分函数描述 （1）类SeqSquare：对类SeqSquare的声明及其中一些函数 class SeqSquare { public: SeqSquare(int n);~SeqSquare();void P(int x);//p操作 void V(int x);//v操作 bool IsEmpty();//判断是否为空 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 bool IsFull();//判断是否已满 void deca();void decb();int getSize();int getmaxSize();int gettop();int geta();int getb();protected: private: };说明：①用动态整型数组*elements来代表缓冲区，不管是生产产品还是对已有产品的消费都需要访问该缓冲区。②函数IsFull（）用于判断缓冲区是否已满，生产者能否使用缓冲区。③函数IsEmpty（）用于判断缓冲区是否为空，消费者能否使用缓冲区。 （2）生产者和消费者操作及显示函数showbuf： void producer(SeqSquare *a)//生产者操作 { } void consumer(SeqSquare *a)//消费者操作 { } //缓冲区显示 void showbuf(SeqSquare *a){ }（3）在实现本程序的生产者消费者模型时，具体地通过以下同步对象实现互斥： int *elements;int top,a,b,maxSize;a->P(1);a->V(1);int i=a->getSize();湖北民族学院信息工程学院11级计算机专业操作系统课程设计 ①设一个互斥量Mutex，以实现生产者在查询和保留缓冲区的下一个空位置时进行互斥。 ②每一个生产者用一个信号量与消费者同步，通过设置Full实现，该组信号量用于表示相应产品以生产。同时用一个表示空缓冲区数目的信号量Empty进行类似的同步，指示缓冲区中是否存在空位置，以便开始生产下一个产品。 （四）调试过程 为解决生产者、消费者问题，应该设置两个资源信号量，其中一个表示空缓冲区的数目，用Full表示，其初值为用户输入的缓冲区的大小，另一个表示缓冲区中产品的数目，用Empty表示，其初值为0.另外，由于缓冲区是一个临界资源，必须互斥使用，所以还需要再设置一个互斥信号量Mutex，其初值为1.在生产者、消费者问题中，信号量实现两种功能。首先，他是生产产品和消费产品的计数器，计数器的初值是可使用的资源数目（缓冲区的长度）。其次，他是确保产品的生产者和消费者之间的动作同步的同步器。 生产者要生产一个产品时，首先对资源信号量Full和互斥信号量Mutex进行P操作，申请资源。如果可以通过的话，就生产一个产品，并把产品送人缓冲区。然后对互斥信号量Mutex和资源信号量Empty进行V操作，释放资源。 消费者要消费一个产品时，首先对资源信号量Empty和互斥信号量Mutex进行P操作，申请资源。如果可以通过的话就从缓冲区取出一个产品并消费掉。然后对互斥信号量Mutex和资源信号量Full进行V操作，释放资源。 如果缓冲区中已经没有可用资源，就把申请资源的进程添加到等待队列的队尾。如果有一个资源被释放，在等待队列中的第一个进程被唤醒并取得这个资源的使用权。 （五）参考资料 《操作系统教程》 孙钟秀 高等教育出版社 《C++程序设计》 谭浩强 高等教育出版社 六、运行实例及结果分析 （一）运行实例 缓冲区大小为3，先生产一件产品，显示缓冲区，再接着生产一件产品，消耗一件产品，显示缓冲区，在消耗两件产品，再生产4件产品，改变缓冲区的大小为6，显示缓冲区，选择一个未出现的选项，退出程序。 （二）结果显示 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 （三）结果分析 （1）在每个程序中需要先做P，后做V，二者要成对出现，夹在二者中间的代码段就是该进程的临界区。 （2）对同步信号量full和empty的P,V操作同样必须成对出现，但它们分别位于不同的程序中。 （3）无论在生产者进程中还是消费者进程中，两个P操作的次序不能颠倒：应先执行同步信号量的P操作，然后执行互斥信号量的P操作。否则可能造成进程死锁。 七、个人体验 虽然我也很想用java语言写这个程序，但是由于自己学艺不精，所以只能用C++写。通过这个实验我发现我以前有很多知识都忘记了，重新拿起课本学习9 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 时发现原来很多不懂得问题都有了新的认识，有一种豁然开朗的感觉。也为我考研开了一个好的开头。 我认为我完成的这个设计做的比较出色的地方是对C++语言中类以及数组的运用，其实这里我对数组的操作是按照“先进先出”的方法进行运作的，这是参考了栈的工作原理，因为缓冲区一般也是堆栈，比较符合设计要求。 这次实验中我感觉做的很粗糙，自己所想的模拟过程的确得到实现了，但是感觉灵活性不太高，思考还不过全面，应该以后多注意一下，多考虑考虑才是。 在这次实验中我重新将《C++程序设计》和《数据结构》的几个重要章节复习了一遍，对类、数组、C++的I/O流类库以及堆栈的语句格式、注意细节都再一次熟悉，感觉蛮有趣的。不过，在编程过程中许多语句的小问题还真是出现不少，而且感觉自己对C++强大丰富的语句方法用得太呆板，不够灵活，总是想到那些常用的，而忽略了颗粒让语句更简短的方法，以后要多多注意才是。 八、附录 // 生产者消费者1.cpp : Defines the entry point for the console application.// #include “stdafx.h” #include “iostream” using namespace std;class SeqSquare { public: SeqSquare(int n);~SeqSquare();void P(int x); //p操作 void V(int x); //v操作 bool IsEmpty(); //判断是否为空 bool IsFull(); //判断是否已满 void deca();void decb();int getSize();int getmaxSize();int gettop();int geta();int getb();protected: private: int *elements;int top,a,b,maxSize;};10 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 bool SeqSquare::IsEmpty() //判断是否为空 { return(top==-1)?true:false;} bool SeqSquare::IsFull() //判断是否已满 { return(top>=maxSize-1)?true:false;} void SeqSquare::deca(){ a--;} void SeqSquare::decb(){ b--;} int SeqSquare::getSize(){ return top+1;} int SeqSquare::getmaxSize(){ return maxSize;} int SeqSquare::gettop(){ return top;} int SeqSquare::geta(){ return a;} int SeqSquare::getb(){ 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 return b;} SeqSquare::SeqSquare(int n){ top =-1;a = b =0;maxSize = n;elements = new int[maxSize];} void SeqSquare::P(int x){ if(IsFull()==true){ a=a+1;} else { elements[++top] = x; } } void SeqSquare::V(int x){ if(IsEmpty()==true){ b = b+1;} else { x = elements[top--]; } } 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 void producer(SeqSquare *a) //生产者操作 { a->P(1);} void consumer(SeqSquare *a) //消费者操作 { a->V(1);} SeqSquare::~SeqSquare(){ delete elements;} //缓冲区显示 void showbuf(SeqSquare *a){ int i=a->getSize(); } int main(){ int i,n;cout<<“请输入缓冲区大小：”< cout<<“请选择操作： ”< 4.退出系统。 ”< ”< switch(i) { case 1: producer(s); if(s->geta()==0) { 湖北民族学院信息工程学院11级计算机专业操作系统课程设计 cout< } else { cout< s->deca(); } break; case 2: consumer(s); if(s->getb()==0) { cout< } else { cout< } break; case 3: showbuf(s); cout< ”<<“可用空间为：”<<(n-s->getSize())< break; case 4: cout< break; case 5: cout< cin>>n; s = new SeqSquare(n); cout< break; default: cout< } } return 0;} 闽江学院 计算机系 网络操作系统课程设计 设计内容：进程机制与并发程序设计——linux下生产者与消费者的问题实现 目录： 一、设计内容····························3 二、设计思想····························4 三、系统结构····························5 四、PV操作代码··························5 五、C++程序代码·························6 六、运行结果截图························9 七、参考文献····························11 八、实验总结····························11 一、设计内容 进程机制与并发程序设计————linux下生产者与消费者的问题实现 1．实验目的 （1）掌握基本的同步互斥算法，理解生产者和消费者同步的问题模型。（2）了解linux中多线程的并发执行机制，线程间的同步和互斥。 2、实验环境：C/C++语言编译器 3、实验要求 （1）创建生产者和消费者线程 在linux环境下，创建一个控制台进程，在此进程中创建n个线程来模拟生产者或者消费者。这些线程的信息由本程序定义的“测试用例文件”中予以指定。 该文件的格式和含义如下： 3 1 P 3 2 P 4 3 C 4 1 4 P 2 5 C 3 1 2 4 第一行说明程序中设置几个临界区，其余每行分别描述了一个生产者或者消费者线程的信息。每一行的各字段间用Tab键隔开。不管是消费者还是生产者，都有一个对应的线程号，即每一行开始字段那个整数。第二个字段用字母P或者C区分是生产者还是消费者。第三个字段表示在进入相应线程后，在进行生产和消费动作前的休眠时间，以秒计时；这样做的目的是可以通过调整这一列参数，控制开始进行生产和消费动作的时间。如果是代表生产者，则该行只有三个字段。如果代表消费者，则该行后边还有若干字段，代表要求消费的产品所对应的生产者的线程号。所以务必确认这些对应的线程号存在并且该线程代表一个生产者。（2）生产和消费的规则 在按照上述要求创建线程进行相应的读写操作时，还需要符合以下要求： ①共享缓冲区存在空闲空间时，生产者即可使用共享缓冲区。 ②从上边的测试数据文件例子可以看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。此时，只有当所有的消费需求都被满足以后，该产品所在的共享缓冲区才可以被释放，并作为空闲空间允许新的生产者使用。 ③每个消费者线程的各个消费需求之间存在先后顺序。例上述测试用例文件包含一行信息“5 C 3 l 2 4”，可知这代表一个消费者线程，该线程请求消费1，2，4号生产者线程生产的产品。而这种消费是有严格顺序的，消费1号线程产品的请求得到满足后才能继续往下请求2号生产者线程的产品。 ④要求在每个线程发出读写操作申请、开始读写操作和结束读写操作时分别显示提示信息。（3）相关基础知识 本实验所使用的生产者和消费者模型具有如下特点： 本实验的多个缓冲区不是环形循环的，也不要求按顺序访问。生产者可以把产品放到目前某一个空缓冲区中。 消费者只消费指定生产者的产品。 在测试用例文件中指定了所有的生产和消费的需求，只有当共享缓冲区的数据满足了所有关于它的消费需求后，此共享缓冲区才可以作为空闲空间允许新的生产者使用。 本实验在为生产者分配缓冲区时各生产者间必须互斥，此后各个生产者的具体生产活动可以并发。而消费者之间只有在对同一产品进行消费时才需要互斥，同时它们在消费过程结束时需要判断该消费对象是否已经消费完毕并清除该产品。 linux用来实现同步和互斥的实体。在linux中，常见的同步对象有：信号量(Semaphore)、互斥量(Mutex)、临界段(CriticalSection)等。使用这些对象都分为三个步骤，一是创建或者初始化：接着请求该同步对象，随即进入临界区，这一步对应于互斥量的上锁；最后释放该同步对象，这对应于互斥量的解锁。这些同步对象在一个线程中创建，在其他线程中都可以使用，从而实现同步互斥。 二、设计思想 生产者进程与消费者进程是经典的同步互斥关系。系统创建两类进程：proceducer()和consumer()，分别用来描述生产者和消费者的行为。生产者与消费者问题是指若干进程通过循环缓冲池区交换数据。如下图所示，生产者进程不断向循环缓冲池区中写入数据（即生产数据），而消费者进程不断从循环缓冲池区中读出数据（即消费数据）。循环缓冲池共有N个缓冲区，缓冲区可以暂存一个产品，任何时刻只能有一个进程课对循环缓冲池进行操作。所有生产者和消费者要协调工作，以完成数据的交换。只要有空缓冲区，生产者就可以把产品送入缓冲区；只要有满缓冲区，消费者就可以从缓冲区中取走物品。 为了解决生产者和消费者问题，应该设置信号量和变量如下： full： 满缓冲区资源信号量，初值为0； empty：空缓冲区资源信号量，初值为n； in： 生产者指针，初值均为0； out： 消费者指针，均为0； mutex：缓冲区操作的互斥信号量，初值为1 三、系统结构 PCB* readyhead=NULL, * readytail=NULL;// 就绪队列——链表结构 PCB* consumerhead=NULL, * consumertail=NULL;// 消费者队列 PCB* producerhead=NULL, * producertail=NULL;// 生产者队列 processproc()---给PCB分配内存，产生相应的的进程 Pempty()---如果缓冲区满，该进程进入生产者等待队列； linkqueue(exe,&producertail);// 把就绪队列里的进程放入生产者队列的尾部 执行顺序：Main()---empty---in---full---out---finish 当缓冲池为空时，生产者生产产品in缓冲池 in=in+1 当缓冲池为满时，消费者消费产品out缓冲池 out=out+1 四、PV操作代码 semaphore empty=n;semaphore full=0;semaphore mutex=1;message buffer[n];int in=0; int out=0;void main(){ parbegin(proceducer(),consumer());} void proceducer(){ do { prodece a new meddage;P(empty);P(mutex);send a new message to buffer[in];in=(in+1)%n;V(mutex);V(full);} while(true);} void consumer(){ do { P(full);P(mutex);get a message from buffer[out];out=(out+1)%n;V(mutex);V(empty);comsume a message;}while(true);} 五、C++程序代码 #include “windows.h” #include “iostream.h” #include “math.h” #define random(rand()*10000)/RAND_MAX //定义一个随机函数来生产产品，并且使两个顾产品间的时间少于10秒 int long waiting(0);//正在等待的产品的数目 int buffer;//空位的总数目 char empty;//缓冲区空 char full;//缓冲区满 int count(0);//产品的号码数 int finish(0);//生产完毕的产品数目 DWORD a;void proceduce() { Sleep(10000);cout<<“缓冲区已空!”< } void getconsum(){ Sleep(10001);//产品被生产的函数，为了合理区分生产产品 cout<<“第”< HANDLE Mutex=CreateMutex(NULL, FALSE, “Mutex”);//用来实现进程的互斥 HANDLE proceducer=CreateSemaphore(NULL, 1,1, “proceducer”);//定义信号量来进行线程间的同步 HANDLE consumer=CreateSemaphore(NULL,0,3,“consum”);DWORD WINAPI consum(LPVOID pParm2)//消费的线程 { WaitForSingleObject(Mutex ,INFINITE);//p(mutex)来进行互斥操作 count++;//生产的是第几个产品 cout<<“第 ”< { if(waiting!=0){ cout<<“此时有”< else cout<<“没有产品在等待”< ReleaseMutex(Mutex);//释放互斥量，以便其他线程使用 WaitForSingleObject(proceducer,INFINITE);//等待生产 getconsum();//消费并取走 } else { cout<<“缓冲区已满，第”< return 0;} DWORD WINAPI proceducers(LPVOID pParm1)//生产者的线程 { while(true)//一直执行 { WaitForSingleObject(consum,INFINITE);//p(customers)，等待产品 WaitForSingleObject(Mutex,INFINITE);//等待互斥量 waiting--;//等待的产品数减一 ReleaseSemaphore(proceducer,1,NULL);//释放信号量 ResumeThread(proceducer);//唤醒消费进程 ReleaseMutex(Mutex);//v(mutex);proceduce();//生产 finish++;//消费的产品数加1 } return 0;} int main(int argc, char* argv[]){ cout<<“请输入缓冲区空位的总数目:”;cin>>buffer;cout<<“缓冲区共有”< cout< HANDLE hThread1;HANDLE hThread2;hThread2=::CreateThread(NULL,0,proceducers,NULL,0,NULL);//产生一个生产者进程 while(full!='y'){ Sleep(random);//产品随机进入 hThread1=::CreateThread(NULL,0,consum,NULL,a,NULL);cout< { cout<<“已经为”< else;} if(full=='y'){ cout<<“********对不起，缓冲区已满********”< } 六、运行结果截图 缓冲区空位总数目为1时运行结果截图： 缓冲区空位总数目为0和3时运行结果截图（其余部分如上当缓冲区空位总数目为1时的截图） 七、参考文献 1、计算机网络操作系统原理与应用 孔宪军 吕滨（本学期教科书） 2、网络操作系统课程设计计划书 陈卫老师 3、C程序设计（第三版）谭浩强 八、实验总结 刚刚看到课程设计的内容与要求时，不禁有点无从下手的感觉。经过一番思考后，才决定选择设计“进程机制与并发程序设计——linux下生产者与消费者的问题实现”这部分。设计这部分不仅仅需要用到C/C++编程，还需要编写相关的PV原语。由于自己的PV原语部分和C/C++编程学的不是很好，因此对我来说有点难。于是我就积极利用书本上的知识来编写PV原语，C/C++编程是参考书上的指点以及网络资源编写出来的。不懂得地方查资料、上网找、问问其他同学，最后终于慢慢的把课程设计做出来了。通过这次课程设计，才感觉到自己还是平时动手少，要经常动手去做实验才能真正学到东西。尤其是一些C/C++编程和PV原语的编写更需要平时多加练习才能学好用好。特别是C/C++编程在遇到语法有多处错误时，不能急，要冷静下来慢慢修改，知道程序正确。虽然是自己独立做的课程设计，但是其中还是有很多不懂的东西是问同学的，因此了解到学习不是单独的，应该是相互交流相互学习的。第二篇：操作系统实验报告经典生产者—消费者问题
第三篇：实验4生产者消费者问题报告
第四篇：操作系统课程设计生产者消费者
第五篇：生产者与消费者的问题-----操作系统课程设计
点击咨询 