生产者消费者模型模拟进程调度_计算机专业_操作系统课程设计_Exp
操作系统课程设计报告-进程调度的模拟实现
操作系统课程设计报告专业计算机科学与技术学生姓名班级学号指导教师完成日期博雅学院ﻬ题目:进程调度的模拟实现的模拟实现一、设计目的本课程设计是学习完“操作系统原理”课程后进行的一次全面的综合训练，通过课程设计，更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解,加强学生的动手能力。
在多道程序和多任务系统中,系统内同时处于就绪状态的进程可能有若干个。
也就是说能运行的进程数大于处理机个数。
为了使系统中的进程能有条不紊地工作,必须选用某种调度策略，选择一进程占用处理机。
要求学生设计一个模拟处理机调度算法,以巩固和加深处理机调度的概念.二、设计内容1)概述选择一个调度算法，实现处理机调度。
设计要求:１)进程调度算法包括：时间片轮转法，短作业优先算法，动态优先级算法。
2)可选择进程数量3)本程序包括三种算法,用C或Ｃ++语言实现，执行时在主界面选择算法(可用函数实现），进入子页面后输入进程数,（运行时间，优先数由随机函数产生),执行，显示结果。
调度时总是选取优先数最大的进程优先运行２．每个进程的优先数，运行时间，由程序任意指定.3．为了调度方便,把进程按给定优先级(动态优先级算法中）从小到大排成一个队列。
按给定运行时间（短作业优先）从小到大排成一个队列用一个变量作为队首指针,指向队列的第一个进程。
4．处理机调度总是选队首进程运行。
由于本实验是模拟处理机调度，所以被选中的进程并不实际的启动运行，而是执行:优先数－1（动态优先级算法中)要求运行时间－1来模拟进程的一次运行。
5.进程运行一次后，若要求运行时间不等于０,则再将它加入队列（动态优先级算法中:按优先数大小插入.)，且改变队首指针：若要求运行时间=0，则把它的状态改为完成（C)状态,且退出队列。
（5)对于遇到优先数一致的情况,采用FIFO策略解决.3。
概要设计(1)本程序用两种算法对五个进程进行调度,每个进程可有三个状态,并假设初始状态为就绪状态。
进程调度算法模拟 (操作系统课程设计报告)
福建农林大学计算机与信息学院课程设计报告课程名称：操作系统实习题目：进程调度算法模拟姓名：系：计算机科学与技术系专业：计算机科学与技术年级：2012学号：指导教师：职称：副教授年月日福建农林大学计算机与信息学院计算机类课程设计结果评定目录1.本选题课程设计的目的 (4)2.本选题课程设计的要求 (4)3.本选题课程设计报告内容 (4)3．1前言 (4)3．2进程调度算法模拟的环境 (4)3．3系统技术分析 (4)3．4系统流程图及各模块 (5)3．5程序调试情况 (8)4．总结 (11)参考文献 (11)程序代码 (12)1.设计目的课程设计将课本上的理论知识和实际有机的结合起来，锻炼学生的分析系统，解决实际问题的能力。
提高学生分析系统、实践编程的能力。
2.设计要求利用学到的操作系统和编程知识，完成具有一定难度的系统分析研究或系统设计题目。
其中：专题系统理论研究应包括研究目的、目标，论点和论据以及证明推导等；分析、设计系统应包括编写、调试程序以及最后写出设计报告或系统说明文档文件，系统说明文档包括系统界面、变量说明、系统功能说明、编程算法或思路、流程图和完整程序。
具体要求如下：1、对系统进行功能模块分析、控制模块分析正确；2、系统设计要实用；3、编程简练，可用，功能全面；4、说明书、流程图要清楚。
3.设计方案3.1前言本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。
3.2本选题设计的环境WindowsXP下的Microsoft Visual C++ 6.03.3系统技术分析（1）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。
操作系统课程设计 生产者与消费者
燕山大学课程设计说明书课程设计名称：操作系统OS题目：多道程序缓冲区协调操作班级：开发小组名称：课题负责人：课题组成员：姓名学号班级自评成绩课题开发日期：一、概述利用MFC类库编写一个可实现多道程序缓冲区协调操作的面向对象的程序。
1.1基本功能演示生产者消费者程序，多线程并发执行的过程；可以控制生产者消费者的个数及生产者生产的速度和消费者的速度，进度条中显示Buffer 中数据的个数，有五个按钮，分别为：开始、继续，暂停、结束、退出,点击开始按钮，程序开始执行，点击暂停按钮，所有线程暂停执行，点击继续按钮，线程继续执行，结束按钮使得所有线程结束执行，点击退出按钮，退出系统，统计按钮按下时显示此时的Buffer1，buffer2的生产者生产的次数和Buffer3的消费者消费的次数，及Move的次数，和开始时间及结束时间。
1.2开发计划10号查阅参考资料，了解整体的框架结构； 11号完成整体模块的构思及设计； 12号完成程序具体的编写任务并调试代码； 13号整理总结并书写报告； 14号验收。
1.3人员分工1.4环境、工具和开发方法本程序在XP系统下，采用的开发语言是C++，它是一种使用非常广泛的面向对象的计算机编程语言。
它支持过程化程序设计、数据抽象、面向对象程序设计、制作图标等多种程序设计风格。
在Visual C++ 6.0编程环境中，利用MFC类库编写C++风格的应用程序，基于MFC类库的应用程序可以快速建立起应用程序，并且类库为我们提供了大量的封装类。
二、需求分析用户需要看到看到并发程序的运行过程，以及能对过程进行控制，可以设计几个按钮控制开始，暂停、结束等功能，并可以让用户自定义生产者消费者数量及生产者消费者线程并发执行的速度，并能以用户能够明白的形式表示出来，可以设计一个进度条显示各个Buffer中的物品数量，并用数字显示出来，看的就清楚了，设置一个统计按钮，当用户点击按钮时，就可以获取当前各个线程的情况，有几个线程在执行，Buffer1的线程个数，Buffer2的线程个数及从开始到结束所用的时间，从而了解线程运行的情况。
操作系统实验——PV操作实现生产者消费者模型
/** * 单个生产者类 * @author Vfdxvffd * @count 生产的物品数量标号 */ class Producer implements Runnable{ int count = 0; //数量 @Override public void run() { while(count < 20) { //最多生产20件商品
Global.empty.Wait(); /*要生产物品了，给剩余空 闲缓冲区数量--，如果减完后变为负数，则说明当前没 有空闲缓冲区，则加入等待队列*/ //临界区，生产商品 int index = count % 2; Global.buffer[index] = count; System.out.println("生产者在缓冲区"+index+"中生产了物品"+count); count++;
假如生产者号生产了0号商品，但此时他还没做Global.pCount++这一步操作，CPU将执行权切换到生产者2号，这时Global.pCount的值还是 刚刚的0，没有加1，所以又会生产出一个0号商品，那消费者也同理，消费完还没加1，就被切换了执行权。
那就有个问题，如果我们将Global.pCount++这一步提前能不能解决问题呢，当然也是不行的，因为可能++完还没输出就被切换执行权，那下次 执行权回来时候就会继续执行输出操作，但此时的Global.pCount的值已经不知道加了多少了。
/*remove a process P from the waiting queue*/ wakeup(P); } }
信号量的应用
操作系统课程设计报告-进程调度算法模拟
1．课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一，是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解，掌握操作系统结构、实现机理和各种典型算法，系统地了解操作系统的设计和实现思路，培养学生的系统设计能力，并了解操作系统的发展动向和趋势。
2．课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。
要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入，也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程，使之执行。
但在其执行期间，只要出现了另一个比其优先级更高的进程，调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。
操作系统进程调度模拟课程设计(java)
计算机操作系统课程设计实验报告题目名称进程调度模拟系统院系班级完成时间2013.1.8 指导老师本次实验成绩组长联系电话邮件地址组长（姓名、学号）主要任务需求分析，模块设计与代码编写，组织任务分配，PPT制作，实验报告审定,材料汇总等成员（姓名、学号）主要任务代码的编写实验报告的编写、材料查找等题目进程调度：模拟FCFS和SJF进程调度过程实验介绍原理现在的处理机任务量大，多个进程会不同时先后到达，并且各个进程的工作时间也不一定相同，为了使各个进程间不发生冲突，有条不紊的先后运行，并以最短的时间占用处理机，面对这种发展状况，有必要使用进程调度算法来提高处理机的工作效率。
去选择合适的一种进程调度算法达到理想的效果，可以做到信息的规范管理、科学统计和快速运作，从而减少时间上的浪费。
用Java语句设计实现登陆界面，直观显示各种算法和调度结果，直观地显示运行结果，设计进程调度算法实现用不同算法（先来先服务，短作业优先，高响应比优先调度算法，时间片轮转算法）进行进程调度，算出最短周转时间，实现高效率调度算法。
参考资料[1] 黄祥喜，计算机操作系统实验教程。
广州：中山大学出版社，1994.[2] 汤子瀛，《计算机操作系统(修订版)》西安电子科技大学出版社[3] Andrew S.Tanenbaum，现代操作系统，机械工业出版社。
[4] (美)Bruce Eckel. Java编程思想. 陈昊鹏译. 北京：机械工业出版社，2007[5] 王路群.Java高级程序设计.北京：中国水利水电出版社，2006[6] 孙卫琴. 精通Struts：基于MVC的Java Web设计与开发.北京：电子工业出版社，2004.08实验环境（软件和硬件）：（1）硬件要求EGA或VGA卡彩显或单显(640×350以上),单机内存2M以上,硬盘40M 以上。
客户端计算机采用586以上机型，客户端应用程序可以稳定的运行在Windows07 xp操作系统之上。
操作系统之进程(生产者---消费者)实验报告
操作系统实验报告——生产者和消费者问题姓名：学号：班级：一、实验内容1、模拟操作系统中进程同步和互斥；2、实现生产者和消费者问题的算法实现；二、实验目的1、熟悉临界资源、信号量及PV操作的定义与物理意义；2、了解进程通信的方法；3、掌握进程互斥与进程同步的相关知识；4、掌握用信号量机制解决进程之间的同步与互斥问题；5、实现生产者－消费者问题，深刻理解进程同步问题；三、实验题目在Windows操作系统下用C语言实现经典同步问题：生产者—消费者，具体要求如下：(1)一个大小为10的缓冲区，初始状态为空。
(2)2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。
页脚内容1(3)2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。
四、思想本实验的主要目的是模拟操作系统中进程同步和互斥。
在系统进程并发执行异步推进的过程中，由于资源共享和进程间合作而造成进程间相互制约。
进程间的相互制约有两种不同的方式。
（1）间接制约。
这是由于多个进程共享同一资源（如CPU、共享输入/输出设备）而引起的，即共享资源的多个进程因系统协调使用资源而相互制约。
（2）直接制约。
只是由于进程合作中各个进程为完成同一任务而造成的，即并发进程各自的执行结果互为对方的执行条件，从而限制各个进程的执行速度。
生产者和消费者是经典的进程同步问题，在这个问题中，生产者不断的向缓冲区中写入数据，而消费者则从缓冲区中读取数据。
生产者进程和消费者对缓冲区的操作是互斥，即当前只能有一个进程对这个缓冲区进行操作，生产者进入操作缓冲区之前，先要看缓冲区是否已满，如果缓冲区已满，则它必须等待消费者进程将数据取出才能写入数据，同样的，消费者进程从缓冲区读取数据之前，也要判断缓冲区是否为空，如果为空，则必须等待生产者进程写入数据才能读取数据。
在本实验中，进程之间要进行通信来操作同一缓冲区。
操作系统课程设计用多进程同步方法解决生产者消费者问题
操作系统课程设计⽤多进程同步⽅法解决⽣产者消费者问题操作系统课程设计⽤多进程同步⽅法解决⽣产者-消费者问题系别：计科系专业: 计算机科学与技术班级：04 级 4 班学号：0410*******姓名：苏德洪时间：2006-7-7—2006-7-14⽬录⼀、题⽬： (3)⼆、设计⽬的： (3)三、总体设计思想概述： (3)四、说明： (3)五、设计要求： (3)六、设计⽅案： (3)七、流程图： (5)⼋、运⾏结果 (7)九、源程序 (11)⼗、总结 (18)⼗⼀、参考⽂献 (20)⼀、题⽬：⽤多进程同步⽅法解决⽣产者-消费者问题。
⼆、设计⽬的：通过研究Linux 的进程机制和信号量实现⽣产者消费者问题的并发控制。
三、总体设计思想概述：1、⽣产者—消费者问题是⼀种同步问题的抽象描述。
2、计算机系统中的每个进程都可以消费或⽣产某类资源。
当系统中某⼀进程使⽤某⼀资源时，可以看作是消耗，且该进程称为消费者。
3、⽽当某个进程释放资源时，则它就相当⼀个⽣产者。
四、说明：有界缓冲区内设有20个存储单元,放⼊/取出的数据项设定为1-20这20个整型数。
1、每个⽣产者和消费者对有界缓冲区进⾏操作后，即时显⽰有界缓冲区的全部内容，当前指针位置和⽣产者/消费者线程的标识符。
2、⽣产者和消费者各有两个以上。
3、多个⽣产者或多个消费者之间须有共享对缓冲区进⾏操作的函数代码。
六、设计⽅案：通过⼀个有界缓冲区(⽤数组来实现，类似循环队列)把⽣产者和消费者联系起来。
假定⽣产者和消费者的优先级是相同的，只要缓冲区未满，⽣产者就可以⽣产产品并将产品送⼊缓冲区。
类似地，只要缓冲区未空，消费者就可以从缓冲区中去⾛产品并消费它。
应该禁⽌⽣产者向满的缓冲区送⼊产品，同时也应该禁⽌消费者从空的缓冲区中取出产品，这⼀机制有⽣产者线程和消费者线程之间的互斥关系来实现。
为解决⽣产者/消费者问题，应该设置两个资源信号量，其中⼀个表⽰空缓冲区的数⽬，⽤g_hFullSemaphore表⽰，其初始值为有界缓冲区的⼤⼩SIZE_OF_BUFFER；另⼀个表⽰缓冲区中产品的数⽬，⽤g_hEmptySemaphore表⽰，其初始值为0。
操作系统课程设计-进程调度算法模拟
操作系统课程设计----进程调度算法模拟一、实验内容：模拟五种进程调度算法并计算各参数值二、实验原理：（1）先来先服务调度：最先到达的进程先进行调度（2）短作业优先调度：从已到达的进程中选出最短的进程优先调度（3）时间片轮转调度：每个进程依次的按时间片轮流的方式执行（4）静态优先权调度：赋予优先权，在已到达的进程中选出优先权最高的优先调度（5）高响应比优先调度：优先权随等待时间而增加，从而使等待时间较长且服务时间较短的进程优先调度响应比=1+等待时间/服务时间三、实验设计说明：本程序采用C++ Builder 5编程和设计界面考虑到调度算法较多，采用了多页面的界面（如下图），加入的进程限制五个，在文本框中模拟到达一进程后，输入到达时间和服务时间，点击“加入新进程”即可，输入完成之后，点击运行即可得到表中各值。
想从新输入可点击“清除”按钮。
关闭时直接点击“×”即可。
该程序还不是很完善，有一些小问题，尚待解决，还得向老师请教。
四、实验结果：（只打印两个结果示范）运行后操作面板初始化如下图：短作业优先结果如图：时间片轮转结果如图：（书上的例题）五、实验源程序：Unit1.h文件//---------------------------------------------------------------------------#ifndef Unit1H#define Unit1H//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Forms.hpp>#include <ComCtrls.hpp>#include <Grids.hpp>#include <ExtCtrls.hpp>//--------------------------------------------------------------------------- class TForm1 : public TForm{__published: // IDE-managed ComponentsTPageControl *PageControl1; TTabSheet *TabSheet1; TTabSheet *TabSheet2; TTabSheet *TabSheet3; TTabSheet *TabSheet4; TabSheet *TabSheet5; TStringGrid *sgr;TButton *Button1;TButton *Button2;TButton *Button3; TStringGrid *sgr1;TButton *Button4;TButton *Button5;TButton *Button6; TStringGrid *sgr2;TButton *Button7;TButton *Button8;TButton *Button9; TStringGrid *sgr3;TButton *Button10; TButton *Button11; TButton *Button12; TStringGrid *sgr4;TButton *Button13; TButton *Button14; TButton *Button15;TLabel *Label1;TEdit *Edit1;TLabel *Label2;TEdit *Edit2;TEdit *Edit3;TEdit *Edit4;TLabel *Label3;TLabel *Label4;TEdit *Edit5;TLabel *Label5;TLabel *Label6;TEdit *Edit6; TLabel *Label7;TEdit *Edit7;TLabel *Label8;TLabel *Label9;TLabel *Label10;TEdit *Edit8;TEdit *Edit9;TEdit *Edit10;TLabel *Label11;TLabel *Label12;TEdit *Edit11;TEdit *Edit12;void __fastcall FormCreate(TObject *Sender);void __fastcall Button3Click(TObject *Sender);void __fastcall Button1Click(TObject *Sender);void __fastcall Button2Click(TObject *Sender);void __fastcall Button6Click(TObject *Sender);void __fastcall Button5Click(TObject *Sender);void __fastcall Button4Click(TObject *Sender);void __fastcall Button9Click(TObject *Sender);void __fastcall Button7Click(TObject *Sender);void __fastcall Button8Click(TObject *Sender);void __fastcall Button12Click(TObject *Sender); void __fastcall Button10Click(TObject *Sender); void __fastcall Button11Click(TObject *Sender);void __fastcall Button15Click(TObject *Sender); void __fastcall Button13Click(TObject *Sender); void __fastcall Button14Click(TObject *Sender);private: // User declarationspublic: // User declarations__fastcall TForm1(TComponent* Owner);};//---------------------------------------------------------------------------extern PACKAGE TForm1 *Form1;//---------------------------------------------------------------------------#endif******************************************************************************* Unit1.cpp文件//--------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop#include "Unit1.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TForm1 *Form1;float super[6]; //优先权float come[6]; //到达时间float serve[6]; //服务时间float begin[6]; //开始执行时间float end[6]; //完成时间float all[6]; //周转时间float dall[6]; //带权周转时间float max(float,float,float);//---------------------------------------------------------------------------__fastcall TForm1::TForm1(TComponent* Owner) //初始化表格: TForm(Owner){}//---------------------------------------------------------------------------void __fastcall TForm1::FormCreate(TObject *Sender){sgr->Cells[0][0]="进程名";sgr1->Cells[0][0]="进程名";sgr2->Cells[0][0]="进程名";sgr3->Cells[0][0]="进程名";sgr4->Cells[0][0]="进程名";sgr3->Cells[0][1]="优先权";sgr->Cells[0][1]="到达时间";sgr1->Cells[0][1]="到达时间";sgr2->Cells[0][1]="到达时间";sgr3->Cells[0][2]="到达时间";sgr4->Cells[0][1]="到达时间";sgr->Cells[0][2]="服务时间";sgr1->Cells[0][2]="服务时间";sgr2->Cells[0][2]="服务时间";sgr3->Cells[0][3]="服务时间";sgr4->Cells[0][2]="服务时间";sgr->Cells[0][3]="开始执行时间";sgr1->Cells[0][3]="开始执行时间";sgr3->Cells[0][4]="开始执行时间";sgr4->Cells[0][3]="开始执行时间";sgr4->Cells[0][4]="等待时间";sgr4->Cells[0][5]="响应比";sgr->Cells[0][4]="完成时间";sgr1->Cells[0][4]="完成时间";sgr2->Cells[0][3]="完成时间";sgr3->Cells[0][5]="完成时间";sgr4->Cells[0][6]="完成时间";sgr->Cells[0][5]="周转时间";sgr1->Cells[0][5]="周转时间";sgr2->Cells[0][4]="周转时间";sgr3->Cells[0][6]="周转时间";sgr4->Cells[0][7]="周转时间";sgr->Cells[0][6]="带权周转时间";sgr1->Cells[0][6]="带权周转时间";sgr2->Cells[0][5]="带权周转时间";sgr3->Cells[0][7]="带权周转时间";sgr4->Cells[0][8]="带权周转时间";sgr->Cells[0][7]="显示调度结果";sgr1->Cells[0][7]="显示调度结果";sgr3->Cells[0][8]="显示调度结果";sgr4->Cells[0][9]="显示调度结果";}//---------------------------------------------------------------------------//先来先服务调度算法void __fastcall TForm1::Button3Click(TObject *Sender) //输入初值，5个{static int i=1;sgr->Cells[i][0]=i; //进程编号sgr->Cells[i][1]=Edit1->Text; //输入到达时间come[i]=StrToFloat(Edit1->Text); //赋到达时间给表格sgr->Cells[i][2]=Edit2->Text; //输入服务时间serve[i]=StrToFloat(Edit2->Text); // 赋服务时间给表格i++;if(i>5) i=1;}//---------------------------------------------------------------------------float max(float x,float y,float m) //定义函数{return (x+y)>m?(x+y):m;}//---------------------------------------------------------------------------//““运行”按键函数void __fastcall TForm1::Button1Click(TObject *Sender){int i=1;begin[1]=come[1];sgr->Cells[1][3]=begin[1]; //初始值for(i=2;i<=5;i++){begin[i]=max(serve[i-1],begin[i-1],come[i]); //调用函数sgr->Cells[i][3]=begin[i];} //开始执行时间for(i=1;i<=5;i++) //计算各个值{end[i]=begin[i]+serve[i];sgr->Cells[i][4]=end[i];all[i]=end[i]-come[i];sgr->Cells[i][5]=all[i];dall[i]=all[i]/serve[i];sgr->Cells[i][6]=dall[i];sgr->Cells[i][7]=i;}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button2Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr->Cells[j][i]="";}}//---------------------------------------------------------------------------//短作业优先调度函数//“加入新进程”输入初值void __fastcall TForm1::Button6Click(TObject *Sender){static int i=1;sgr1->Cells[i][0]=i; //进程编号sgr1->Cells[i][1]=Edit3->Text;come[i]=StrToFloat(Edit3->Text);sgr1->Cells[i][2]=Edit4->Text;serve[i]=StrToFloat(Edit4->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button5Click(TObject *Sender){ int i=0,j=0;for(i=0;i<=7;i++)for(j=1;j<=5;j++){sgr1->Cells[j][i]="";}}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button4Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //flag用于设置访问值“1”为未访问sgr1->Cells[1][7]="1";begin[1]=come[1];sgr1->Cells[1][3]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr1->Cells[1][4]=FloatToStr(end[1]);sgr1->Cells[1][5]=FloatToStr(end[1]-come[1]);sgr1->Cells[1][6]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++; //index自动指向下一个进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k; //index指向第一个未执行的进程break;}}for(i=2;i<=5;i++)//满足三个条件的进程才可调度，1、已到达2、未调度过3、服务时间最小{ if ((come[i]<=end[run])&&(serve[index]>serve[i])&&(flag[i]==1)){index=i;}else if (come[i]>end[run]) //如果一进程完成未有进程到达，则下一个进程到来就直接调度break;}flag[index]=0;//处理index，index为当前运行的进程编号，run为上一个进程的编号begin[index]=max(serve[run],begin[run],come[index]); //开始执行时间sgr1->Cells[index][3]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index]; //计算完成时间sgr1->Cells[index][4]=FloatToStr(end[index]);all[index]=end[index]-come[index]; //计算周转时间sgr1->Cells[index][5]=FloatToStr(all[index]);sgr1->Cells[index][6]=FloatToStr(all[index]/serve[index]); //赋带权周转时间t[j]=index; // t[j]为调度序列}for(i=1;i<=4;i++)sgr1->Cells[i+1][7]=FloatToStr(t[i]); //显示调度结果}//---------------------------------------------------------------------------//时间片轮转调度算法void __fastcall TForm1::Button9Click(TObject *Sender){static int i=1;sgr2->Cells[i][0]=i; //进程编号sgr2->Cells[i][1]=Edit5->Text;come[i]=StrToFloat(Edit5->Text);sgr2->Cells[i][2]=Edit6->Text;serve[i]=StrToFloat(Edit6->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button7Click(TObject *Sender){int i=1,j=1,flag[6]={1,1,1,1,1,1};float t=0,q,a[6]; // q为时间片大小q=StrToFloat(Edit7->Text); //赋值给qfor(i=1;i<=5;i++)a[i]=serve[i];for(j=1;j<=100;j++) //设总时间片不超过100{for(i=1;i<=5;i++){if(flag[i]==1){ serve[i]-=q; //计算服务时间if(serve[i]>0){t+=q; //t为当前执行的总时间}else if(serve[i]<=0){t+=(q+serve[i]); //t为当前执行的总时间end[i]=t; //进程调度完毕送完成时间flag[i]=0; //一旦进程被调度后置flag值为0}}}}for(i=1;i<=5;i++) //显示结果{sgr2->Cells[i][3]=FloatToStr(end[i]);all[i]=end[i]-come[i];sgr2->Cells[i][4]=FloatToStr(all[i]);sgr2->Cells[i][5]=FloatToStr(all[i]/a[i]);}}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button8Click(TObject *Sender){int i=0,j=0;for(i=0;i<=6;i++)for(j=1;j<=5;j++){sgr2->Cells[j][i]="";}}//---------------------------------------------------------------------------//优先权调度算法（原理类似短作业优先）//“加入新进程”输入初值void __fastcall TForm1::Button12Click(TObject *Sender){static int i=1;sgr3->Cells[i][0]=i; //进程编号sgr3->Cells[i][1]=Edit8->Text;super[i]=StrToFloat(Edit8->Text);sgr3->Cells[i][2]=Edit9->Text;come[i]=StrToFloat(Edit9->Text);sgr3->Cells[i][3]=Edit10->Text;serve[i]=StrToFloat(Edit10->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button10Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4]; //run为上一个调度的进程号sgr3->Cells[1][8]="1";begin[1]=come[1];sgr3->Cells[1][4]=FloatToStr(begin[1]);end[1]=begin[1]+serve[1];sgr3->Cells[1][5]=FloatToStr(end[1]);sgr3->Cells[1][6]=FloatToStr(end[1]-come[1]);sgr3->Cells[1][7]=FloatToStr((end[1]-come[1])/serve[1]);//初始化for(j=1;j<=4;j++){index++;while(flag[index]==0){index++;} //index指向下一个待运行的进程if (index>5) //index值的复位{for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<=end[run])&&(super[index]>super[i])&&(flag[i]==1)){index=i; //满足条件的进程号送给index}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr3->Cells[index][4]=FloatToStr(begin[index]);run=index;end[index]=begin[index]+serve[index];sgr3->Cells[index][5]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr3->Cells[index][7]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr3->Cells[i+1][8]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button11Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr3->Cells[j][i]="";}//---------------------------------------------------------------------------//高响应比优先调度算法（类似优先权调度算法，响应比为动态的）//“清除”按键函数void __fastcall TForm1::Button15Click(TObject *Sender){static int i=1;sgr4->Cells[i][0]=i; //进程编号sgr4->Cells[i][1]=Edit11->Text;come[i]=StrToFloat(Edit11->Text);sgr4->Cells[i][2]=Edit12->Text;serve[i]=StrToFloat(Edit12->Text);i++;if(i>5) i=1;}//---------------------------------------------------------------------------//“运行”按钮函数void __fastcall TForm1::Button13Click(TObject *Sender){int i,j,k,run=1,index=1,flag[6]={1,1,1,1,1,1},t[4];float xy[6]; //xy[]为响应比数组sgr4->Cells[1][9]="1";begin[1]=come[1];sgr4->Cells[1][3]=FloatToStr(begin[1]);sgr4->Cells[1][4]="0";xy[1]=1+0;sgr4->Cells[1][5]=FloatToStr(xy[1]);end[1]=begin[1]+serve[1];sgr4->Cells[1][6]=FloatToStr(end[1]);sgr4->Cells[1][8]=FloatToStr((end[1]-come[1])/serve[1]); //初始化for(j=1;j<=4;j++){index++;if (index>5){for(k=2;k<=5;k++)if (flag[k]==1){index=k;break;}}for(i=2;i<=5;i++){ if ((come[i]<end[run])&&((end[run]-come[index])/serve[index]<(end[run]-come[index])/serve[i]) &&(flag[i]==1)) //动态计算响应比并比较{index=i;}else if (come[i]>end[run])break;}flag[index]=0;//处理indexbegin[index]=max(serve[run],begin[run],come[index]);sgr4->Cells[index][3]=FloatToStr(begin[index]);sgr4->Cells[index][4]=FloatToStr(end[run]-come[index]);xy[index]=1+(end[run]-come[index])/serve[index];sgr4->Cells[index][5]=FloatToStr(xy[index]);run=index;end[index]=begin[index]+serve[index];sgr4->Cells[index][6]=FloatToStr(end[index]);all[index]=end[index]-come[index];sgr4->Cells[index][7]=FloatToStr(all[index]);sgr4->Cells[index][8]=FloatToStr(all[index]/serve[index]);t[j]=index;}for(i=1;i<=4;i++)sgr4->Cells[i+1][9]=FloatToStr(t[i]);}//---------------------------------------------------------------------------//“清除”按键函数void __fastcall TForm1::Button14Click(TObject *Sender){int i=0,j=0;for(i=0;i<=9;i++)for(j=1;j<=5;j++)sgr4->Cells[j][i]="";}//---------------------------------------------------------------------------六、实验总结：此次实验花了一周多的时间完成了程序的编写和界面设计，这其中也走了不少弯路。
计算机操作系统实验-生产者和消费者
重庆交通大学综合性设计性实验报告班级：软件专业 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类对象中出栈。