东南大学 操作系统实验2 生产者-消费者问题
操作系统生产者与消费者问题实验报告
《操作系统》实验报告生产者和消费者的问题一、实验目的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.在多线程矩阵开发实验中,刚开始定义矩阵太小,测试结果不太明显,后面通过把矩阵改大,并且线程数目不断变化使得结果明显。
操作系统实验报告生产者消费者问题
操作系统课程设计一.实验目标完成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。
操作系统中的经典问题——生产者消费者问题(两种方式实现)
操作系统中的经典问题——⽣产者消费者问题(两种⽅式实现)操作系统中的经典问题——⽣产者消费者问题(两种⽅式实现)1、问题引⼊:什么是⽣产者消费者问题?⽣产者消费者问题(英语:Producer-consumer problem),也称有限缓冲问题(英语:Bounded-buffer problem),是⼀个多线程同步问题的经典案例。
该问题描述了共享固定⼤⼩缓冲区的两个线程——即所谓的“⽣产者”和“消费者”——在实际运⾏时会发⽣的问题。
⽣产者的主要作⽤是⽣成⼀定量的数据放到缓冲区中,然后重复此过程。
与此同时,消费者也在缓冲区消耗这些数据。
该问题的关键就是要保证⽣产者不会在缓冲区满时加⼊数据,消费者也不会在缓冲区中空时消耗数据。
.要解决该问题,就必须让⽣产者在缓冲区满时休眠(要么⼲脆就放弃数据),等到下次消费者消耗缓冲区中的数据的时候,⽣产者才能被唤醒,开始往缓冲区添加数据。
同样,也可以让消费者在缓冲区空时进⼊休眠,等到⽣产者往缓冲区添加数据之后,再唤醒消费者。
通常采⽤进程间通信的⽅法解决该问题。
如果解决⽅法不够完善,则容易出现死锁的情况。
出现死锁时,两个线程都会陷⼊休眠,等待对⽅唤醒⾃⼰。
该问题也能被推⼴到多个⽣产者和消费者的情形。
2、问题分析该问题需要注意的⼏点:1. 在缓冲区为空时,消费者不能再进⾏消费2. 在缓冲区为满时,⽣产者不能再进⾏⽣产3. 在⼀个线程进⾏⽣产或消费时,其余线程不能再进⾏⽣产或消费等操作,即保持线程间的同步4. 注意条件变量与互斥锁的顺序由于前两点原因,因此需要保持线程间的同步,即⼀个线程消费(或⽣产)完,其他线程才能进⾏竞争CPU,获得消费(或⽣产)的机会。
对于这⼀点,可以使⽤条件变量进⾏线程间的同步:⽣产者线程在product之前,需要wait直⾄获取⾃⼰所需的信号量之后,才会进⾏product的操作;同样,对于消费者线程,在consume之前需要wait直到没有线程在访问共享区(缓冲区),再进⾏consume的操作,之后再解锁并唤醒其他可⽤阻塞线程。
操作系统_生产者与消费者问题的实现
//shmctl(shmid,IPC_RMID,&buf);
//del_sem(semid);
return 0;
}
/*生产者写5次后退出*/
void producer(key_t keyFull, key_t keyEmpty)
empty Write P1 : 2
empty Write P2 : 4
in = 0
Write : 5
full Write V1 : 0
full Write V2 : 0
full Read P2 : 0
out = 0
Read : 5
empty Read V1 : 4
empty Read V2 : 5
Write : 7
full Write V1 : 0
full Write V2 : 0
full Read P2 : 0
out = 2
Read : 7
empty Read V1 : 4
empty Read V2 : 5
Read Finish
p(empty); /*是否有空缓冲区,有则占有,无则被挂起,是原子操作*/
printf("empty Write P2 : %d\n", semctl(empty, 0, GETVAL, 0));
value_write++;
in = in++;
pData[in] = value_write;
in = in % 5;
printf("full Write V2 : %d\n", semctl(full, 0, GETVAL, 0));
计算机操作系统课程设计报告《生产者---消费者问题》
计算机操作系统课程设计报告《生产者---消费者问题》《计算机操作系统》课程设计题目:生产者---消费者问题专业:软件工程年级: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、加深对并发协作进程同步与互斥概念的理解。
通过编写程序实现进程同步和互斥,使学生掌握有关进程(线程)同步与互斥的原理,以及解决进程(线程)同步和互斥的算法,从而进一步巩固进程(线程)同步和互斥等有关的内容。
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。
操作系统生产者和消费者问题
生产者-消费者问题是一个经典的进程同步问题,已经属于化石级别的了。
该问题最早由Dijkstra 提出,用以演示他提出的信号量机制。
要求设计在同一个进程地址空间内执行的两个线程。
生产者线程生产物品,然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品,然后释放缓冲区。
当生产者线程生产物品时,如果没有空缓冲区可用,那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时,如果没有满的缓冲区,那么消费者线程将被阻塞,直到新的物品被生产出来。
要求设计并实现一个进程,该进程拥有一个生产者线程和一个消费者线程,它们使用N个不同的缓冲区(N为一个自定义的确定的数值,例如N=32)。
需要使用如下信号量:•一个互斥信号量,用以阻止生产者线程和消费者线程同时操作缓冲区列表;•一个信号量,当生产者线程生产出一个物品时可以用它向消费者线程发出信号;•一个信号量,消费者线程释放出一个空缓冲区时可以用它向生产者线程发出信号;看代码吧://pv操作:生产者与消费者经典问题//author:leaf#include<stdio.h>#include<stdlib.h>#include<unistd.h>#include<pthread.h>#include<semaphore.h>#define M 32 /*缓冲数目*/#define P(x)sem_wait(&x)#define V(x)sem_post(&x)int in = 0;/*生产者放置产品的位置*/int out = 0;/*消费者取产品的位置*/int buff[M]={0};/*缓冲初始化为0,开始时没有产品*/sem_t empty_sem;/*同步信号量,当满了时阻止生产者放产品*/sem_t full_sem;/*同步信号量,当没产品时阻止消费者消费*/pthread_mutex_t mutex;/*互斥信号量,一次只有一个线程访问缓冲*//**output the buffer*/void print(){int i;for(i = 0; i < M; i++)printf("%d ", buff[i]);printf("\n");}/**producer*/void*producer(){for(;;){sleep(1);P(empty_sem);pthread_mutex_lock(&mutex);in = in % M;printf("(+)produce a product. buffer:");buff[in]= 1;print();++in;pthread_mutex_unlock(&mutex);V(full_sem);}}/**consumer*/void*consumer(){for(;;){sleep(2);P(full_sem);pthread_mutex_lock(&mutex);out = out % M;printf("(-)consume a product. buffer:");buff[out]= 0;print();++out;pthread_mutex_unlock(&mutex);V(empty_sem);}}void sem_mutex_init(){/**semaphore initialize*/int init1 = sem_init(&empty_sem, 0, M);int init2 = sem_init(&full_sem, 0, 0);if((init1 != 0)&&(init2 != 0)){printf("sem init failed \n");exit(1);}/**mutex initialize*/int init3 =pthread_mutex_init(&mutex,NULL);if(init3 != 0){printf("mutex init failed \n");exit(1);}}int main(){pthread_t id1;pthread_t id2;int i;int ret;sem_mutex_init();/*create the producer thread*/ret =pthread_create(&id1,NULL, producer,NULL);if(ret != 0){printf("producer creation failed \n");exit(1);}/*create the consumer thread*/ret =pthread_create(&id2,NULL, consumer,NULL);if(ret != 0){printf("consumer creation failed \n");exit(1);}pthread_join(id1,NULL);pthread_join(id2,NULL);exit(0);}程序执行结果:其中1表示已经生产出的产品,1的个数就代表已生产出的产品个数。
实习2 并发控制-多生产者消费者问题 操作系统高级 教学课件
银行服务问题
题目说明(1)
实习要求
• 在Windows环境下,编程实现银行业务服务 问题,用P、V操作实现柜台人员和顾客进程 的程序
• 银行业务服务问题:银行有n个柜员负责为 顾客服务,顾客进入银行先取一个号码,然 后等着叫号;当某个柜员空闲下来,就叫下 一个号
银行服务问题
题目说明(2)
实现提示
WaitForSingleObjects • 说明:当指定对象处于有信号状态或者超时的时候, 该函数返回
• 返回值:若成功,返回值表明引起函数返回的时间, 可能为WAIT_ABANDONED,WAIT_OBJECT_0 和WAIT_TIMEOUT;若函数失败,返回 WAIT_FAILED • 参数 hHandle:等待对象句柄 dwMilliseconds:指定以毫秒为单位的超时间隔
API(续)
WaitForMultipleObjects • 说明:当任意一个或全部指定对象处于有信号状态 或者超时,则该函数返回 • 返回值:若函数成功,返回值表明引起函数返回的 事件 • 参数 nCount:指明由lpHandles所指向的数组中的对象句 柄数目 lpHandles:对象句柄数组的指针 fWaitAll:指明等待类型 dwMilliSeconds:指明以毫秒为单位的超时间隔
决方法的不同。 6.本实验出现的函数及其参数,名称与含义。
API
CreateMutex • 说明:创建一个互斥对象 • 返回值:如执行成功,就返回互斥体对象的句柄; 零则表示出错 • 参数
lpMutexAttributes :指向 SECURITY_ATTRIBUTES 结构的指针,该结构决 定子进程师父能继承返回句柄。若 lpMutexAttributes为NULL,则该句柄不能被继承 bInitialOwner :若创建进程希望立即拥有该互斥 对象,则设为TRUE ;否则设为FALSE lpName :互斥对象的名字
《操作系统概论》实验指导书-实验二 经典的生产者—消费者问题
实验二经典的生产者—消费者问题一、目的实现对经典的生产者—消费者问题的模拟,以便更好的理解经典进程同步问题。
二、实验内容及要求编制生产者—消费者算法,模拟一个生产者、一个消费者,共享一个缓冲池的情形。
1、实现对经典的生产者—消费者问题的模拟,以便更好的理解此经典进程同步问题。
生产者-消费者问题是典型的PV操作问题,假设系统中有一个比较大的缓冲池,生产者的任务是只要缓冲池未满就可以将生产出的产品放入其中,而消费者的任务是只要缓冲池未空就可以从缓冲池中拿走产品。
缓冲池被占用时,任何进程都不能访问。
2、每一个生产者都要把自己生产的产品放入缓冲池,每个消费者从缓冲池中取走产品消费。
在这种情况下,生产者消费者进程同步,因为只有通过互通消息才知道是否能存入产品或者取走产品。
他们之间也存在互斥,即生产者消费者必须互斥访问缓冲池,即不能有两个以上的进程同时进行。
三、实验环境操作系统环境:Windows或DOS系统。
编程语言:Turbo C、Visual C++、broland C++、Visual Basic、Delphi、Java等。
四、实验思路和设计1、程序流程图由学生完成。
2、主要程序代码//初始化变量Private Sub Form1_Load(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles MyBase.Loadmutex = 1 //互斥信号量full = 0 //缓冲池中满缓冲区的数量empty = 7 //缓冲池中空缓冲区的数量count1 = 0 //生产的产品数目i = 0End Sub//消费者从缓冲区中消费一个产品Private Sub consumer_Click(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles consumer.ClickIf full > 0 Then //有供消费的缓冲区产品If mutex = 1 Then //申请进入临界区mutex = 0 //消费者已进入互斥临界区labmutex.Text = "0"timer_consumer.Enabled = True //启动消费者消费缓冲区产品Else : MsgBox("缓冲区正被占用,请等待!", 5 + MsgBoxStyle.Exclamation,"信息提示") //不能进入临界区End IfElse : MsgBox("已无可用缓冲区供消费!", 5 + MsgBoxStyle.Exclamation,"信息提示") //无缓冲区产品供消费End IfEnd Sub//生产者向缓冲区中存入一个产品Private Sub producer_Click(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles producer.Clickcount1 = count1 + 1 //生产一个产品If empty > 0 Then //有缓冲区可放产品If mutex = 1 Then //申请进入临界区mutex = 0 //生产者已进入临界区labmutex.Text = "0"timer_production.Enabled = True //启动生产者将产品放入缓冲区Else //不能进入临界区count1 = count1 - 1MsgBox("缓冲区正被占用,请等待!", 7 + MsgBoxStyle.Exc lamation,"信息提示")End IfElse : MsgBox("已无可用缓冲区供存入!", 7 + MsgBoxStyle.Exclamation,"信息提示") //无缓冲区可放产品count1 = count1 - 1End IfEnd Sub//生产者Private Sub timer_production_Tick(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles timer_production.TickIf bool ThenPicture1(count1).Visible = Truelabelshow.Text = "生产者进程正在占用缓冲区,请等待!"bool = FalseElsePicture1(count1).Visible = Falselabelshow.Text = "生产者进程正在占用缓冲区,请等待!"bool = TrueEnd Ifi = i + 1If i = 7 Then //循环缓冲区,首尾相接i = 0timer_production.Enabled = Falsemutex = 1labmutex.Text = "1"Picture1(count1).Visible = Truefull = full + 1labfull.Text = Str(full)empty = empty - 1labempty.Text = Str(empty)labelshow.Text = " Ready "End IfEnd Sub//消费者Private Sub timer_consumer_Tick(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles timer_consumer.TickIf bool ThenLabel1(count1).BackColor = System.Drawing.ColorTranslator.FromOle(&HFF00)labelshow.Text = "消费者进程正在占用缓冲区,请等待!"bool = FalseElseLabel1(count1).BackColor =System.Drawing.ColorTranslator.FromOle(&H8000000F) Picture1(count1).Visible = Falselabelshow.Text = "消费者进程正在占用缓冲区,请等待!"bool = TrueEnd Ifi = i + 1If i = 7 Theni = 0timer_consumer.Enabled = Falsemutex = 1labmutex.Text = "1"Label1(count1).BackColor =System.Drawing.ColorTranslator.FromOle(&H8000000F)Picture1(count1).Visible = Falsecount1 = count1 - 1full = full - 1labfull.Text = Str(full)empty = empty + 1labempty.Text = Str(empty)labelshow.Text = " Ready "End IfEnd Sub3、运行界面和运行结果一般情况下,点一次producer按纽,mutex由1变为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;}。
操作系统实验报告生产者与消费者问题模拟
操作系统上机实验报告实验名称:生产者与消费者问题模拟实验目的:通过模拟生产者消费者问题理解进程或线程之间的同步与互斥。
实验内容:1、设计一个环形缓冲区,大小为10,生产者依次向其中写入1到20,每个缓冲区中存放一个数字,消费者从中依次读取数字。
2、相应的信号量;3、生产者和消费者可按如下两种方式之一设计;(1)设计成两个进程;(2)设计成一个进程内的两个线程。
4、根据实验结果理解信号量的工作原理,进程或线程的同步\互斥关系。
实验步骤及分析:一.管道(一)管道定义所谓管道,是指能够连接一个写进程和一个读进程的、并允许它们以生产者—消费者方式进行通信的一个共享文件,又称为pipe文件。
由写进程从管道的写入端(句柄1)将数据写入管道,而读进程则从管道的读出端(句柄0)读出数据。
(二)所涉及的系统调用1、pipe( )建立一无名管道。
系统调用格式pipe()参数定义int pipe();int [2];其中,[1]是写入端,[0]是读出端。
该函数使用头文件如下:#include <unistd.h>#inlcude <signal.h>#include <stdio.h>2、read( )系统调用格式:read(fd,buf,nbyte)功能:从fd所指示的文件中读出nbyte个字节的数据,并将它们送至由指针buf所指示的缓冲区中。
如该文件被加锁,等待,直到锁打开为止。
参数定义:int read(fd,buf,nbyte);int fd;char *buf;unsigned nbyte;3、write( )系统调用格式read(fd,buf,nbyte)功能:把nbyte 个字节的数据,从buf所指向的缓冲区写到由fd所指向的文件中。
如文件加锁,暂停写入,直至开锁。
参数定义同read( )。
(三)参考程序#include <unistd.h>#include <signal.h>#include <stdio.h>int pid1,pid2;main( ){int fd[2];char outpipe[100],inpipe[100];pipe(fd); /*创建一个管道*/while ((pid1=fork( ))==-1);if(pid1==0){lockf(fd[1],1,0);/*把串放入数组outpipe中*/sprintf(outpipe,"child 1 is using pipe!");/*向管道写长为50字节的串*/write(fd[1],outpipe,50);sleep(5); /*自我阻塞5秒*/lockf(fd[1],0,0);exit(0);}else{while((pid2=fork( ))==-1);if(pid2==0){lockf(fd[1],1,0); /*互斥*/sprintf(outpipe,"child 2 is using pipe!");write(fd[1],outpipe,50);sleep(5);lockf(fd[1],0,0);exit(0);}else{wait(0); /*同步*/read(fd[0],inpipe,50);/*从管道中读长为50字节的串*/printf("%s\n",inpipe);wait(0);read(fd[0],inpipe,50);printf("%s\n",inpipe);exit(0);}}}编写过程:运行结果:二、信号机制(一)信号的基本概念每个信号都对应一个正整数常量(称为signal number,即信号编号。
操作系统实验报告生产者消费者问题
《操作系统课程设计》实验报告生产者消费者问题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 原理在同一个进程地址空间内执行的两个线程生产者线程生产物品,然后将物品放置在一个空缓冲区中供消费者线程消费。
消费者线程从缓冲区中获得物品,然后释放缓冲区。
当生产者线程生产物品时,如果没有空缓冲区可用,那么生产者线程必须等待消费者线程释放出一个空缓冲区。
当消费者线程消费物品时,如果没有满的缓冲区,那么消费者线程将被阻塞,直到新的物品被生产出来。
操作系统实验 生产者与消费者问题
实验一生产者和消费者问题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簪巷
操作系统生产者消费者问题实验报告
实验报告二实验名称:一、生产者-消费者问题的多线程解决方案二、设计一个执行矩阵乘法的多线程程序日期:2015-10-22 班级:13级计科学号:姓名:一、实验目的1.掌握线程的同步与互斥2.掌握生产者消费者的实现问题3.掌握多线程的编程方法4.掌握矩阵乘法的基本计算原理以及实现二、实验内容1.生产者-消费者问题的多线程解决方案2.设计一个执行矩阵乘法的多线程程序三、项目要求与分析1.请查阅资料,掌握线程创建的相关知识以及矩阵乘法的相关知识,了解java语言程序编写的相关知识2.理解线程的实验步骤在本次试验中,以“生产者-消费者”模型为依据,提供了一个多线程的“生产者-消费者”实例,编写java代码调试运行结果,得出相应的结论。
理解矩阵乘法的实验步骤四、具体实现1.生产者-消费者实例(1)创建一个缓冲信息发送接收通道接口,并创建邮箱盒子类实现,主要代码如下://通道接口public interface Channel{public 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(new Producer(mailBox));Thread consumerThread=new Thread(new Consumer(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.在多线程矩阵开发实验中,刚开始定义矩阵太小,测试结果不太明显,后面通过把矩阵改大,并且线程数目不断变化使得结果明显。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
do {
wait(full)
wait(mutex);
…
从 buffer 中移除一个 product
…
signal(mutex);
signal(empty);
…
对得到的 product 进行各种操作
…
} while (true);
结束程序
主程序流程图如下:
Start
Initialize semaphores
Remove a product from buffer
Signal semaphore: mutex
Signal semaphore: empty
Consume the product
主要数据结构及其说明
本程序主要用到 bounded-buffer 来存储缓存的数据,为方便起见,缓冲区中的内容为 int 类 型。缓冲区主要结构如下图:
实验目的
通过实验,理解 Win32 API、Pthreads 中 mutex locks、semaphores 等使用方法,并掌握如 何利用它们实现进程(线程)间的同步和互斥。
设计思路及流程图
初始化信号量值(full, empty, mutex)
利用系统调用,创建 Producer 和 Consumer 的线程若干
front rear
环形缓冲区,拥有 front 和 rear 两个指针,以及 isEmpty 一个布尔变量。其中 front 表示缓冲 区的头部,rear 表示缓冲区尾部,isEmpty 表示缓冲区是否为空。
插入一个元素时,改变 isEmpty=true,如果尚未填满(front != rear)并且插入后移动 rear 指针指向下一个空槽。
} }
HANDLE thConsumers[WORKER_SIZE]; HANDLE thProducers[WORKER_SIZE]; const DWORD TIMEOUT = 60000; void init_threads() {
for(int i=0; i<WORKER_SIZE; i++) { //Create consumer and worker threads. thConsumers[i] = CreateThread(NULL, 0, ConsumerProcess, NULL, 0, NULL); thProducers[i] = CreateThread(NULL, 0, ProducerProcess, NULL, 0, NULL);
DWORD WINAPI ProducerProcess(LPVOID arg) { while(true) { //PrintLine(); //Produce an item srand(time(NULL)); int product = rand() + GetCurrentThreadId();
int RemoveFromBuffer() { if(front!=rear || isFull) { int r = buffer[front]; cout << "[X] Removed " << r << " from buffer." << endl; isFull = false; front = (front+1)%MAX_SEMAPHORE_VALUE; return r; } else { //Empty cerr << "Buffer empty!" << endl; return -1; }
实验内容
操作系统实验报告
09010422 何博伟
2013 年 4 月 27 日
在 Windows 和 Linux 操作系统上,利用各自操作系统提供的 Mutex 和信号量机制(Win32 API 或 Pthreads),实现生产者/消费者问题。具体要求见”Operating System Concepts(Seventh Edition)” Chapter 6 后的 Project(P236-241)。
DWORD WINAPI ConsumerProcess(LPVOID arg) { while(true) { //PrintLine(); //Wait until buffer is full //cout << "Waiting for buffer full..." << endl; WaitForSingleObject(full, INFINITE); //Wait until there's no mutex //cout << "Waiting for mutex..." << endl; WaitForSingleObject(mutex, INFINITE); //Remove an item from buffer PrintLineL(); cout << "Consumer "<< GetCurrentThreadId() << " has entered critical section." <<
}
#ifdef WIN32 HANDLE full, empty, mutex; void init_semaphores() {
//Initialize semaphores cout << "Win32 OS detected. Initializing semaphores..." << endl; full = CreateSemaphore(NULL, 0, MAX_SEMAPHORE_VALUE, NULL); empty = CreateSemaphore(NULL, MAX_SEMAPHORE_VALUE, MAX_SEMAPHORE_VALUE, NULL); mutex = CreateSemaphore(NULL, 1, 1, NULL); cout << "Semaphores created." << endl; }
AddToBuffer(product); PrintLineR(); //Critical things done. ReleaseSemaphore(mutex, 1, NULL); //cout << "Mutex released..." << endl; ReleaseSemaphore(full, 1, NULL); //cout << "Full signaled..." << endl; cin.get();
#include <iostream> #include <math.h> #include <time.h> #include <stdlib.h> //调用rand()及srand()函数 using namespace std;
const int MAX_SEMAPHORE_VALUE = 5; //a.k.a MAX_BUFFER_SIZE int buffer[MAX_SEMAPHORE_VALUE]; //buffer int front=0, rear=0; bool isFull = false; const int WORKER_SIZE = 20;
}
bool AddToBuffer(int p) { if(isFull) { //Full.
cerr << "Buffer full, cannot insert " << p << " ." << endl; return false; } buffer[rear] = p; cout << "[+] Inserted " << p << " into buffer." << endl; rear = (rear+1)%MAX_SEMAPHORE_VALUE; if(rear == front) isFull = true; return true; }
#ifdef linux //Under linux sem_t full, empty, mutex;
void init_semaphores() { cout << "Linux detected. Initializing semaphores..." << endl; //sem_init() 初始化一个定位在 sem 的匿名信号量。value 参数指定信号量的初始值。 pshared
删除元素时,先取出 front 指向的元素,然后将 front 往后移动一位,如果 front==rear, 则缓冲区空,置 isEmpty=true。
源程序及注释
#ifdef WIN32 #include <Windows.h> #endif
#ifdef linux #include <pthread.h> #include <semaphore.h> #endif
Producer 线程执行函数:
பைடு நூலகம்do { …
产生一个新的 product
…
wait(empty);
wait(mutex);
…
将新产生的 product 放入 buffer 中