合肥工业大学操作系统课程设计呈报

装订线内请勿答题0学专班学生姓0 - 1 -文 华 学 院2017 ～2018 学年度第 2 学期《操作系统课程设计》考查试卷（A 卷） 课程性质：（必修 ） 使用范围：（本科） 考查时间：2018年3月2 日 考查方式：（ 开卷）试 题： 要 求： 独立完成，3000-8000字（不含附件）。

目录一、课程设计任务及要求 (3)1.1设计任务 (3)1.2设计要求 (3)二、算法及数据结构 (3)2.1主要数据结构 (3)2.2用户管理模块 (5)2.2.1初始化用户函数 (5)2.2.2系统用户的输出函数 (6)2.2.3用户的查找函数 (6)2.3创建文件函数 (6)2.4删除文件函数 (8)2.5打开文件函数 (9)3.6读文件函数 (11)3.7写文件函数 (11)3.8关闭文件函数 (12)3.9显示文件函数 (13)3.9.1显示用户文件 (13)3.9.2显示已打开的文件 (13)三、程序设计与实现 (18)4.1 程序流程图 (18)4.2 程序说明 (18)4.3 实验结果 (19)四、参考文献 (21)六、收获、体会和建议 (22)七、附录源程序清单 (23)装订线内请勿答题0学专班学生姓0 - 3 -一、课程设计任务及要求 1.1 设计任务 设计、实现一个模拟的文件系统 1.2 设计要求 建立文件存储介质的管理机制 建立目录（采用一级目录结构） 文件系统功能（显示目录、创建、删除、打开、关闭、读、写） 文件操作接口（显示目录、创建、删除、打开、关闭、读、写） 独立完成课程设计内容 文本的课程设计报告，内容包括调试记录和程序清单(附注释)。

二、算法及数据结构 2.1主要数据结构 /* *定义文件数据结构 */ typedef struct file { char file_name[20] ; bool file_protect[3] ; bool open_file_protect[3] ; //仅在文件打开时有效 int read , write ; //定义为读写指针 int file_length ; struct file *next ; } File ;/* *用户与文件的映射 */typedef struct x_map {char userName[20] ;File *file ;struct x_map *next ;} Map ;/* *定义主文件目录 */typedef struct mfd{Map *head , *tail ;} MFD ;/* *打开文件目录 */typedef struct afd{File *head , *tail ;int max_open ;int current_open ;} AFD ;主文件目录（MFD）和用户文件目录（UFD）装订线内请勿答题0学专班学生姓- 5 -打开文件目录（AFD ）2.2用户管理模块 2.2.1初始化用户函数 void initUser(MFD *mfd) { //初始化两个不同用户 for (int i = 1 ; i <= 2 ; i++) { Map *m ; m = (Map*)malloc (sizeof (Map)) ; if (m == NULL) { exit (0) ; } cout <<"Please input init user name : " ; cin >>m->userName ; m->file = NULL ; m->next = NULL ; if (mfd->head == NULL) { mfd->head = mfd->tail = m ; }else{mfd->tail->next = m ;mfd->tail = m ;}}}初始化两个不同用户，把输入用户的用户名下的目录指针、文件指针初始化2.2.2系统用户的输出函数void displayUser(MFD *mfd){Map *m = NULL ;m = mfd->head;cout<<"user : " ;while(m){cout<<m->userName<<" " ;m = m->next ;}cout<<endl ;}通过用户与文件关联映射的指针来输出已存在的用户数据2.2.3用户的查找函数Map * queryUser(char userName[] , MFD *mfd){Map *m = NULL ;m = mfd->head ;while(m){if(strcmp(userName , m->userName) == 0)装订线内请勿答题0学专班学生姓- 7 - { return m ; } m = m->next ; } return NULL ; } 进行用户的查找，找到则返回用户映射指针 2.3创建文件函数 bool createFile(Map *user , char file_name[] , bool file_protect[3] , int file_length) { File *file ; file = (File*)malloc (sizeof (File)) ; if (file == NULL) { return false ; } //进行文件的初始化 strcpy (file->file_name , file_name) ; file->file_protect[0] = file_protect[0] ; file->file_protect[1] = file_protect[1] ; file->file_protect[2] = file_protect[2] ; file->file_length = file_length ; file->read = file->write = 0 ; file->next = NULL ;if (user->file == NULL){user->file = file ;}else{File *op , *preOp = NULL ;op = user->file ;//查找是否存在同名文件while(op){if(strcmp(op->file_name , file->file_name) == 0){cout<<"The file name "<<file->file_name<<" is alreadyexit ! "<<endl ;return false ;}preOp = op ;op = op->next ;}preOp->next = file ;}}输入文件名，文件权限及文件长度，将文件的名称、读写权限、长度等进行初始化，然后查找是否存在同名文件，存在同名文件时则输出该文件已存在并报错2.4删除文件函数bool deleteFile(Map *user , char file_name[] , AFD *afd){File *file = NULL , *prefile = NULL , *temp ; file = afd->head ;//在打开文件中查找装订线内请勿答题学专班学生姓 0 - 9 -while (file) { if (strcmp (file_name , file->file_name) == 0) { cout <<"\""<<file_name<<"\" is open , please close it before ! \n" ;return false ; } file = file->next ; } file = user->file ; //在文件中进行查找 while (file) { if (strcmp (file_name , file->file_name) == 0) { if (file == user->file) { temp = file ; user->file = file->next ; } else { temp = file ; prefile->next = file->next ; } delete temp ; return true ; }prefile = file ;file = file->next ;}if(prefile->next == NULL){cout<<"user "<<user->userName<<" has not the file \""<<file_name<<"\""<<endl;}return false ;}输入要删除的文件名，先看该文件是否打开，在打开文件链表中查找，若是打开文件则输出提示该文件已打开请先关闭文件，若不是则在用户文件中查找，找到则进行删除操作，没有则输出提示该用户没有此文件并报错2.5打开文件函数bool openFile(Map *user , char file_name[] , AFD *afd , bool open_file_protect[]){File *file = NULL ;file = user->file ;while(file){if(strcmp(file->file_name , file_name) == 0){break ;}file = file->next ;}if(file)装订线内请勿答题0学 专 班 学生姓 0- 11 -{File *xfile ;xfile = (File*)malloc (sizeof (File)) ; if (xfile == NULL) {return false ; }*xfile = *file ;//根据文件的权限进行打开权限的赋值if (xfile->file_protect[0] >= open_file_protect[0]) {xfile->open_file_protect[0] = open_file_protect[0] ;} else {cout <<"no read priority ! "<<endl; return false ;}if (xfile->file_protect[1] >= open_file_protect[1]) {xfile->open_file_protect[1] = open_file_protect[1] ; } else {cout <<"no write priority ! "<<endl; return false ; }if (xfile->file_protect[2] >= open_file_protect[2]) {xfile->open_file_protect[2] = open_file_protect[2] ;}else{cout<<"no excute priority ! "<<endl;return false ;}xfile->next = NULL ;if(afd->head == NULL){afd->head = afd->tail = xfile ;afd->current_open += 1 ;}else if(afd->current_open < afd->max_open){afd->tail->next = xfile ;afd->tail = xfile ;afd->current_open += 1 ;}else{cout<<"The open file is too many ! " <<endl ; return false ;}}else{cout<<"the "<<file_name<<" is not exit !"<<endl ; return false ;装订线内请勿答题0学 专 班 学生姓 0- 13 -} }输入要打开的文件名及文件权限，根据文件名在文件链表中查找，若没有找到则输出提示该文件不存在，若找到则根据输入的文件权限判断该文件是否有读、写、执行的权限，若没有则输出相关提示并报错，若有相关权限则输出该文件的读写信息。

北华航天工业学院《操作系统》课程设计报告课设报告题目：进程调度算法、银行家算法、虚拟内存中的页面置换磁盘调度算法作者所在系部：计算机科学与工程系作者所在专业：计算机科学与技术作者所在班级：B09512作者姓名：丁小玲指导教师姓名：赵辉完成时间：2011.12.14北华航天工业学院教务处制随着科学技术的发展，计算机在人们的生活领域中占据了重要的地位。

计算机中最最关键的就是操作系统，它直接对计算机的硬件就行了管理，为人们提供了人机界面，使人们可以更方便高效的利用电脑。

我们应该掌握操作系统中进程调度，内存管理，设备管理以及文件管理中重要的过程，这样有利于我们以后更好的了解操作系统。

进程调度算法主要有三种算法，分别是先来先服务、短进程优先算法和高响应比优先算法；银行家算法主要是针对资源分配后，系统是否安全的判断；虚拟内存中的页面置换主要有三种算法，分别是先进先出算法、最近最久未使用算法和最佳置换算法；磁盘调度算法主要有三种算法，分别是先来先服务算法、最短寻道时间优先算法、扫描算法和循环扫描算法。

关键词：先进先出安全算法循环扫描最短寻道第一章绪论 (1)1.1 课程设计的背景和意义 (1)1.1.1 课程设计的理论研究基础 (1)1.1.2 课程设计的意义 (1)1.2 课程设计环境 (2)第二章需求分析 (3)2.1 功能要求 (3)2.1.1 进程调度算法 (3)2.1.2银行家算法 (3)2.1.3 虚拟内存中的页面置换 (3)2.1.4 磁盘调度算法 (3)2.2 问题的解决方案 (4)2.2.1 进程调度算法 (4)2.2.2银行家算法 (4)2.2.3 虚拟内存中的页面置换 (4)2.2.4 磁盘调度算法 (5)第三章系统设计 (6)3.1 数据设计 (6)3.1.1 结构体设计 (6)3.1.2 函数设计 (6)第四章系统实现 (9)4.1 结构体实现 (9)4.1.1 进程调度算法 (9)4.2 函数实现 (9)4.2.1进程调度算法 (9)4.2.2银行家算法 (12)4.2.3虚拟内存中的页面置换算法 (13)4.2.4磁盘调度算法 (17)4.3 主函数实现 (19)4.3.1 进程调度算法的运行界面 (19)4.3.2 银行家算法的运行界面 (19)4.3.3 虚拟内存中的页面置换的运行界面 (20)4.3.4磁盘调度算法的运行界面 (21)4.4 系统界面 (21)4.4.1 进程调度算法的运行界面 (21)4.4.2 银行家算法的运行界面 (22)4.4.3 虚拟内存中的页面置换算法的运行界面 (22)4.4.4 磁盘调度算法的运行界面 (22)第五章系统测试 (23)5.1 模块测试 (23)5.1.1 进程调度算法的模块测试 (23)5.1.2 银行家算法的模块测试 (23)5.1.3虚拟内存中的页面置换算法的模块测试 (24)5.1.4 磁盘调度算法的模块测试 (25)5.2 课程设计过程中遇到的问题 (26)总结 (27)致谢 (28)参考文献 (29)附录 (30)第一章绪论随着科学技术的发展，计算机在人们的生活领域中占据了重要的地位。

实验一汇编运行环境及方法、简单程序设计一、程序说明本程序用来比较两个字符串string1和string2所含的字符是否相同。

若相同则显示‘Match’，否则显示‘Nomatch’。

在程序的数据段先定义两个字符串string1和string2，再定义两个字符串mess1和mess2，分别代表‘Match’和‘Nomatch’。

再代码段比较字符串string1和string2，通过比较判断是否相同。

若相同则显示‘Match’，否则显示‘Nomatch’。

二、调试说明再EDIT中建立ASM文件，再用汇编程序对源程序汇编产生目标文件Obj，再用连接程序产生执行文件EXE。

再用Debug进行调试。

其中常用到的指令有：用-g命令来用运行程序，用-u命令来显示程序，用-d 命令来查看数据段的情况，用-e或-f命令来修改需要改正的部分，用-t指令来逐步执行程序，用-r指令来查看寄存器和修改寄存器的值，-q命令用来退出debug程序。

在这些命令的后面加上地址，可以将命令执行到相应的地方。

如用-g指令运行程序后，再用-u指令显示程序的执行借给如下：三：源程序和执行结果：DATA SEGMENTSTRING1 DB 'Move the cursor backward.' STRING2 DB 'Move the cursor backward.' mess1 db 'match.',10,13,'$'mess2 db 'no match.',10,13,'$'DATA ENDScode segmentmain proc farassume cs:code,ds:DATA,es:DATAstart:mov ax,DATAmov ds,axmov es,axlea si,STRING1lea di,STRING2cldmov cx,25repz cmpsbjz matchlea dx,mess2jmp short dispmatch:lea dx,mess1disp:mov ah,9int 21hmov ah,4chint 21hretmain endpcode endsend start执行结果：实验二用DEBUG编程:使用堆栈段将AX和BX的内容进行交换等一：程序说明：1、设堆栈指针SP=2000H，AX=3000H，BX=5000H；编一程序段将AX和BX的内容进行交换。

操作系统实验报告班级：计算机科学与技术姓名：学号：实验3 进程的创建一、实验目的练习使用EOS API 函数CreateProcess 创建一个进程，掌握创建进程的方法，理解进程和程序的区别。

调试跟踪CreateProcess 函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。

二、实验过程记录1./*Hello.c*/#include "EOSApp.h"int main(int argc, char* argv[]){int i;for (i = 1; i <= 5; i++) {printf("Hello,world! %d\n", i);Sleep(1000);}printf("Bye-bye!\n");return 0;}作用:测试软盘镜像中的程序。

输出"Hello,world! I”并循环输出五次,每次挂起1000ms,最后输出” Bye-b ye!”。

结果:2./*NewProc.c*/#include "EOSApp.h"int main(int argc, char* argv[]){STARTUPINFO StartupInfo;PROCESS_INFORMATION ProcInfo;ULONG ulExitCode; // 子进程退出码INT nResult = 0; // main 函数返回值。

0 表示成功，非0 表示失败。

#ifdef _DEBUG__asm("int $3\n nop");#endifprintf("Create a process and wait for the process exit...\n\n");//// 使子进程和父进程使用相同的标准句柄。

//StartupInfo.StdInput = GetStdHandle(STD_INPUT_HANDLE);StartupInfo.StdOutput = GetStdHandle(STD_OUTPUT_HANDLE);StartupInfo.StdError = GetStdHandle(STD_ERROR_HANDLE);//// 创建子进程。

一.设计题目第9题：进程死锁的检测：绘制资源分配图要求：1)建立资源分配图的数据结构描述；2)建立绘制资源分配图的历程，包括结点和有向边；3)可以删除、添加节点或有向边。

4)可以鼠标在串口的任意位置指点，确定结点或者有向边的位置；5)可以拖动现有结点的位置，使之相关的结点移动6)可以存入文件和从文件中读取。

二.设计原理及算法描述UNIX命令:ls [选项]列出文件信息(默认为当前目录)ls无参显示一个目录中的文件和子目录ls -l每行仅显示一个目录或名称ls --help 显示此帮助信息并离开mkdir目录若目录不存在则创建目录mkdir --help显示此帮助信息并离开rmdir目录若目录没有数据则删除目录rmdir --help显示此帮助信息并离开cp来源文件目的文件将来源文件复制到目的文件cp --help显示此帮助信息并离开cat文件或：cat 文件1 >> 文件2显示文件内容或连接两个文件，并将结果输出到显示屏上cat文件将文件的内容输出到显示屏上cat 文件1 >> 文件2将文件1连接到文件2的结尾，并输出到显示屏上cat --help 显示此帮助信息并离开more文件使文件能逐行(回车键)或逐页(空格键)显示并显示当前文件所占总文件的百分比more --help显示此帮助信息并离开mv文件1 文件2或：mv 文件目录重命名或移动文件mv 文件1 文件2将文件1名字改为文件2的名字mv 文件目录将指定文件移动到指定目录下mv --help显示此帮助信息并离开sort文件将文本文件内容加以排序sort --help显示此帮助信息并离开按照每个命令的功能编写一个实现函数。

通过c++字符串操作从输入流获得指令以及参数，通过对指令以及参数的判别调用对应指令的函数，实现对windows内文件的各项操作。

三.开发环境硬件环境：个人PC机软件环境：Microsoft Windows XPMicrosoft Visual C++ 6.0四.重要算法和设计思路描述命令以及参数的获取：由于命令加参数最多能有四部分，所以申请4个字符串数组。

合工大操作系统课程设计一、课程目标知识目标：1. 理解操作系统的基本概念，掌握操作系统的发展历程、功能及分类。

2. 学会分析操作系统的核心组成部分，如进程管理、内存管理、文件系统、设备管理。

3. 掌握操作系统的基本原理，如进程调度、内存分配、文件权限控制等。

技能目标：1. 能够运用进程管理的基本方法，编写简单的进程同步与互斥程序。

2. 学会使用操作系统提供的API进行文件操作和设备控制。

3. 能够分析并优化操作系统的性能，提高系统资源利用率。

情感态度价值观目标：1. 培养学生对操作系统的学习兴趣，激发他们探索计算机科学领域的热情。

2. 培养学生的团队协作精神，提高他们在项目实践中的沟通与协作能力。

3. 培养学生具备良好的计算机伦理道德观念，尊重知识产权，遵循法律法规。

本课程针对合肥工业大学高年级本科生，课程性质为专业核心课。

结合学生特点，课程目标注重理论与实践相结合，培养学生具备扎实的操作系统能力。

在教学过程中，要求学生积极参与讨论、实践，达到学以致用的目的。

课程目标分解为具体学习成果，以便后续教学设计和评估，确保学生能够全面掌握操作系统知识，提高实践能力。

二、教学内容本课程教学内容主要包括以下几部分：1. 操作系统概述：介绍操作系统的发展历程、功能、分类及其在计算机系统中的作用。

2. 进程管理：讲解进程与线程的概念、进程调度算法、进程同步与互斥、死锁与饥饿问题。

3. 内存管理：阐述内存分配策略、虚拟内存技术、页式和段式存储管理、内存碎片问题。

4. 文件系统：介绍文件和目录结构、文件权限控制、文件系统性能优化、磁盘空间分配策略。

5. 设备管理：讲解设备驱动程序、I/O调度策略、中断处理、设备分配与回收。

6. 操作系统实例分析：以Linux操作系统为例，分析其内核架构、进程管理、内存管理、文件系统等关键技术。

7. 操作系统性能评价与优化：介绍操作系统性能指标、性能评价方法、常用优化策略。

教学内容根据课程目标和教材章节进行合理安排，保证教学内容的科学性和系统性。

中文题目英文题目设计报告作者：学生1 学生2 学生3 学生4 学生5 指导教师：李新荣团队照片口号：《操作系统课程设计》任务书设计目的：本课程设计是学生学习完《操作系统》课程后，进行的一次全面的综合训练，通过课程设计，让学生更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。

设计时间：两周。

设计要求：1．每5人组成一个团队，每个团队开发一个操作系统内核，内核具有传统操作系统的基本功能，包括：处理机管理、内存管理、设备管理、作业管理、用户接口等。

每部分的算法可根据需要简单或复杂。

2．课程设计做完后，按组进行验收和答辩，验收和答辩合格后，给出相应的成绩。

3．每个团队写一份课程设计报告，要在报告中写明分工情况。

4．课程报告要按照模版撰写，报告中要写明：（1）软件功能描述（2）界面说明（3）程序处理流程（4）任务的定义及实现（5）调试过程中遇到的问题和解决的方法（6）进一步改进方案和应用建议（7）使用说明书设计步骤：1．选定题目，每组提交设计方案（初期检查）；2．项目中期检查，每个团队提交中期检查报告，写出目前开发状况；3．项目验收和答辩。

成绩评定：课程设计成绩按100分制计算，评定的依据有考勤、设计文档资料、项目验收和答辩四个成绩组成。

总成绩=考勤*10%+设计文档*30%+项目验收*40%+答辩*20%。

提交的资料：课设完成后要提交项目的设计方案、用户手册、源程序等内容，课设提交具体内容见下面的清单：课设提交内容清单注：（1）开发文档交打印版，提交完整的设计报告。

（2）刻光盘：以上所有内容均放到光盘中，每组一分提交时间：12月18号摘要在计算机网络高速发展的今天，计算机技术不断地更新与完善，无论是硬件还是软件的变更都会在计算机操作系统的设计技术与使用风格上得到体现。

操作系统是计算机系统配置的所有软件中使用最广泛的基础软件，它在整个计算机系统软件中处于中心地位，也是计算机专业课教学中做重要的环节之一。

《 操作系统 》课程设计报告系 别： 信息科学与技术系专业班级：学生姓名：指导教师：（课程设计时间：2010年7月5日——2010年7月9日）目 录一、课程设计目的和意义 (3)二、课程设计题目描述及算法 (3)三、课程设计报告内容 (3)1.算法描述 (3)2.数据结构 (4)3.主要函数说明 (4)4.算法流程图 (5)5.运行结果及说明 (7)6.附录清单及分析 (8)四、总结 (14)一、课程设计目的和意义了解掌握银行家算法，学会模拟实现资源分配，同时有要求编写和调试一个系统分配资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生二、课程设计题目描述及算法题目：银行家算法设计设计要求：编制银行家算法通用程序，并检测所给状态的系统安全性。

设进程I提出请求Request[N]，则银行家算法按如下规则进行判断。

(1)如果Request[N]<=NEED[I，N]，则转(2)；否则，出错。

(2)如果Request[N]<=AVAILABLE，则转(3)；否则，出错。

(3)系统试探分配资源，修改相关数据：AVAILABLE=AVAILABLE-REQUESTALLOCATION=ALLOCATION+REQUESTNEED=NEED-REQUEST(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状，进程等待。

上述三个矩阵存在如下关系：Need[i,j]= Max[i，j]- Allocation[i，j]三、课程设计报告内容1.算法描述设Request[i] 是进程Pi的请求向量，如果Requesti[j]=K,表示进程Pi需要K 个Rj类型的资源，当Pi发出资源请求后，系统按下面步骤进行检查：，便转向步骤2；否则认为出错，因为它所需（1）如果Requesti[j]<=Need[i,j]要的资源数已超过它所宣布的最大值。

操作系统实验报告班级：计算机科学与技术姓名：学号：实验3 进程的创建一、实验目的练习使用EOS API 函数CreateProcess 创建一个进程，掌握创建进程的方法，理解进程和程序的区别。

调试跟踪CreateProcess 函数的执行过程，了解进程的创建过程，理解进程是资源分配的单位。

二、实验过程记录1./*Hello.c*/#include "EOSApp.h"int main(int argc, char* argv[]){int i;for (i = 1; i <= 5; i++) {printf("Hello,world! %d\n", i);Sleep(1000);}printf("Bye-bye!\n");return 0;}作用:测试软盘镜像中的程序。

输出"Hello,world! I”并循环输出五次,每次挂起1000ms,最后输出” Bye-bye!”。

结果:2./*NewProc.c*/#include "EOSApp.h"int main(int argc, char* argv[]){STARTUPINFO StartupInfo;PROCESS_INFORMATION ProcInfo;ULONG ulExitCode; // 子进程退出码INT nResult = 0; // main 函数返回值。

0 表示成功，非0 表示失败。

#ifdef _DEBUG__asm("int $3\n nop");#endifprintf("Create a process and wait for the process exit...\n\n");//// 使子进程和父进程使用相同的标准句柄。

//StartupInfo.StdInput = GetStdHandle(STD_INPUT_HANDLE);StartupInfo.StdOutput = GetStdHandle(STD_OUTPUT_HANDLE);StartupInfo.StdError = GetStdHandle(STD_ERROR_HANDLE);//// 创建子进程。

操作系统课程设计课程设计目的本设计的目的是实现操作系统和相关系统软件的设计，其中涉及进程编程、I/O操作、存储管理、文件系统等操作系统概念。

课程设计要求（1）对进行认真分析，列出实验具体步骤，写出符合题目要求的程序清单，准备出调试程序使用的数据。

（2）以完整的作业包的形式提交原始代码、设计文档和可运行程序。

提交的光盘应当包括：设计题目，程序清单，运行结果分析，所选取的算法及其优缺点，以及通过上机取得了哪些经验。

程序清单要求格式规范，注意加注释（包含关键字、方法、变量等），在每个模块前加注释，注释不得少于20%。

课程设计要求同时上交打印文档，设计报告包括设计题目，算法分析,关键代码及其数据结构说明，运行结果分析以及上机实践的经验总结。

设计一：设计任务：模拟Linux文件系统在任一OS下，建立一个大文件，把它假象成一张盘，在其中实现一个简单的模拟Linux文件系统。

1.在现有机器硬盘上开辟100M的硬盘空间，作为设定的硬盘空间。

2.编写一管理程序simdisk对此空间进行管理，以模拟Linux文件系统，要求：（1）盘块大小1k（2）空闲盘块的管理：Linux位图法（3）结构：超级块, i结点区, 根目录区3.该simdisk管理程序的功能要求如下：(1)info: 显示整个系统信息(参考Linux文件系统的系统信息)，文件可以根据用户进行读写保护。

目录名和文件名支持全路径名和相对路径名，路径名各分量间用“/”隔开。

(2)cd …: 改变目录：改变当前工作目录，目录不存在时给出出错信息。

(3)dir …: 显示目录：显示指定目录下或当前目录下的信息，包括文件名、物理地址、保护码、文件长度、子目录等（带/s参数的dir命令，显示所有子目录）。

(4)md …: 创建目录：在指定路径或当前路径下创建指定目录。

重名时给出错信息。

(5)rd …: 删除目录：删除指定目录下所有文件和子目录。

要删目录不空时，要给出提示是否要删除。

《操作系统课程设计》
总结报告
学期2012-2013学年第二学期
学院软件学院
学号20113311
姓名杜常数
2013 年6月28日
图3.2 SDT类图
图3.4 CHCT类图
图3.5 添加设备流程图
（2）.删除设备：
①输入要删除的设备名称name；②根据名称在SDT表中查找与
同的设备，若没有查找到，则提示出错返回；③否则检查设备是否正忙，
图4.4 FileManage类图算法设计及流程图
(1)md命令的实现:
图4.5 md命令流程图
(2)cd命令的实现:
对于cd命令只需从命令行中提取出要打开的目录名，对链表中的所点遍历查找type为1的与name相同的结点，若
pdnow->pfnow=p->child若找不到显示系统找不到路径即可。

实现的代码如下所示：
void FileManage::cd(string name)
{
File *p=pdnow->pfnow;
if(name=="\\"){
pdnow->pfnow=pdnow->root;
return ;
图5.8 HRN抢占流程图
时间片轮转调度算法，将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时把CPU分配给队首进程，令其执行一个时间片，当时间片用完时把它送到就绪队列的末尾，然后再给就绪队列的队首进程执行。

直到所有进程执行完毕退出即可。

多级反馈队列调度算法，算法的执行如下所述：。

《操作系统》课程设计报告(2006-2007年度第1学期)题目：进程通信与进程同步机制实践班级：计0401学号：3040602015姓名：陈前进教师：鞠时光2007-1-26一.课程设计内容进程通信与进程同步机制实践[问题描述］有三个进程R、M、P，分别负责从键盘读入数据、对读入的数据进行处理、将处理后的数据从屏幕输出，三个进程共享同一个缓冲区。

试用操作系统提供的进程通信和同步机制，使三个进程能够相互协作，正确的完成数据的读入、处理和输出。

［具体要求］1．可以选择Linux(gcc)或者Windows(VC 6.0)作为开发平台。

最终程序的运行界面可以是图形化窗口，也可以是命令行窗口。

2．三个进程通信采用共享缓冲区机制，缓冲区应至少能存放10组数据，每组数据是一个不超过31字节的字符串。

3．数据处理进程（M）的职责是：将读入的一组数据中的○1所有大写字母转换为小写字母（但每个句子的第一个字母应该大写），○2去掉单词与单词之间、句子与句子之间多余的空格，○3如果某个标点既不是句号，也不是逗号，则将其改为句号。

以上三个功能你可以只实现其中的一个、二个或者三个功能。

4．三个进程应该能够持续不断的运行，除非你要求它终止。

二.设计思路1.设计的基本思想:三个进程R、M、P，分别负责从键盘读入数据、对读入的数据进行处理、将处理后的数据从屏幕输出，三个进程共享同一个缓冲区。

定义缓冲区和信号量靠进程通信机制来实现。

进程通信机制，简单的说，就是进程交。

换信息的方式。

由于进程不能互相访问对方的资源，所以，它们要交换信息，只能借助操作系统这个桥梁。

操作系统提供了一种称之为“内核对象”的东西，这个内核对象，它属于操作系统拥有，而不是某一个特定的进程，所以理论上，操作系统中的所有进程都可以访问它们。

内部进程间通讯和数据交换有多种方式：消息、共享内存、匿名（命名）管道、邮槽、Windows套接字等多种技术。

在此次课程设计中，所采用的是共享内存的技术。

合肥工业大学计算机与信息学院实验报告课程：计算机操作系统专业班级：计算机科学与技术2班学号：姓名：实验1 实验环境的使用一.实验目的1.熟悉操作系统集成实验环境OS Lab的基本使用方法。

2.练习编译、调试EOS操作系统内核以及EOS应用程序。

二.实验内容1．启动OS Lab2. 学习OS Lab的基本使用方法2.1新建Windows控制台应用程序项目2.2生成项目2.3执行项目2.4调试项目2.4.1 使用断点中断执行2.4.2单步调试2.4.3查看变量的值2.4.4调用堆栈3. EOS内核项目的生成和调试3.1新建EOS内核项目3.2生成项目3.3调试项目3.4查看软盘镜像文件中的内容3.5查看EOS SDK（Software Development Kit）文件夹4. EOS应用程序项目的生成和调试4.1新建EOS应用程序项目4.2生成项目4.3调试项目4.4查看软盘镜像文件中的内容4.5修改EOS应用程序项目名称5 退出OS Lab6 保存EOS内核项目三.实验结果本实验主要是熟悉EOS操作系统的基本操作，练习了：（1）新Windows控制台应用程序项，1.“文件”菜单中选择“新建”，然后单击“项目”。

2. 在“新建项目”对话框中，选择项目模板“控制台应用程序 (c)”。

3. 在“名称”中输入新项目使用的文件夹名称“oslab”。

4. 在“位置”中输入新项目保存在磁盘上的位置“C:\test”。

新建完毕后， OS Lab 会自动打开这个新建的项目。

（2）在“生成”菜单中选择“生成项目”。

结果如图（3）执行项目：选择“调试”菜单中的“开始执行”（4）调试项目:1. 右键点击“项目管理器”窗口中的“源文件”文件夹节点，在弹出的快捷菜单中选择“添加”中的“添加新文件”。

2. 在弹出的“添加新文件”对话框中选择“C 源文件”模板。

3. 在“名称”中输入文件名称“func”。

4. 点击“添加”按钮，添加并自动打开文件func.c，此时的“项目管理器”窗口会如图：（5）. 在 func.c 文件中添加函数：int Func (int n) { n = n + 1;return n; }（6）. 点击源代码编辑器上方的console.c标签，切换到console.c文件。

操作系统课程设计任务书适用专业：计算机科学技术网络工程电子专业安徽建筑工业学院电子与信息工程学院2014年 6 月前言对计算机科学与技术及相关专业的学生而言，操作系统是一门重要的专业基础课程。

要学好操作系统的设计原理，除了听课、看书、做习题外，最好的方法就是在实践中进行，包括使用操作系统、阅读和分析已有操作系统的源代码、自己设计小型系统/模块或模拟算法等。

从个人的角度而言，如果能够完成MINUX源代码的阅读与分析，这将对掌握操作系统的原理与设计方法不无益处。

这里，我没有向大家推荐Linux或者FreeBSD之类的操作系统（虽然我从1997年就一直向学生推荐FreeBSD），是因为这里的阅读源代码的目标是为了掌握操作系统的原理。

孟子曰：“富贵不能淫，贫贱不能移，威武不能屈，此之谓大丈夫。

”我的理解，即使不能够按照孟老夫子的话去做大丈夫，如果能够做到“时髦不能跟”，也就可以做真正的自己了。

对我们课程的学习，也就是这个道理吧。

操作系统实践，按深度可分为使用级、观察级、系统管理级、源码阅读级和实现级等五个层次。

具体地，1.使用级：是指如何使用操作系统，包括对命令（以及菜单和shell）、系统调用和系统文件的使用。

2.观察级：是指通过使用级的接口，从外部观察操作系统的内部工作过程和结构。

3.系统管理级：是指系统或设备的安装、配置和性能调整。

4.源码阅读级：是指对现有操作系统部分内核源代码的阅读。

5.实现级：是指编程模拟实现操作系统某些功能模块。

上述五个层次的实践，不同层次的实践者可以根据自己的实际情况自主安排，在本课程设计中，每次有对各个任务的层次明确区分，大家仁者见仁吧。

如果可能，给自己创造使用Unix或类Unix的实现环境。

课程设计要求实现以后，应及时写出课程设计报告，报告应包括以下内容：1.设计目的和内容。

2.程序说明，包括程序结构、各模块的算法。

3.调试正确的源程序。

4.程序运行记录（包括对不同测试数据的运行结果）。

课 程 设 计动态分区分配存储管理2010 年 12 月设计题目 学 号 专业班级 学生姓名指导教师合肥工业大学课程设计任务书第一章课程设计概述1.1 设计任务:动态分区分配存储管理1.2 设计要求建立描述内存分配状况的数据结构；建立描述进程的数据结构；使用两种方式产生进程：（a）自动产生，（b）手工输入；在屏幕上显示内存的分配状况、每个进程的执行情况；建立分区的分配与回收算法，支持紧凑算法；时间的流逝可用下面几种方法模拟：（a）按键盘，每按一次可认为过一个时间单位； (b) 响应WM_TIMER；将一批进程的执行情况存入磁盘文件，以后可以读出并重放；支持算法：首次适应算法、循环首次适应算法、最佳适应算法：最坏适应算法。

1.3 设计目的旨在让我们更好的了解动态分区管理方面的知识.第二章原理及算法描述2.1动态分区分配算法原理首次适应算法* 算法概述：分配内存时，从链首开始顺序查找，找到满足的空闲分区则划出空间分配，余下的空闲空间仍保留在空闲链表中* 实现方法：分配时从数组第一个元素开始比较，若符合条件则将该元素减去对应作业的值循环首次适应算法* 算法概述：由首次适应算法演变，只是每次分配改为由上一次找到的空闲分区开始查找* 实现方法：在首次适应算法的基础上增加一个值用于记录找到的空闲分区的位置最佳适应算法* 算法概述：每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业* 实现方法：我们决定每次分配先把空闲分区按从小到大的顺序排列，然后将第一个匹配分区分配给作业最坏适应算法* 算法概述：每次为作业分配内存时，总是挑选一个最大的空闲分区分割给作业使用* 实现方法：算法与最佳适应算法几乎相同，仅在排序时把空闲分区表按从大到小的顺序排列，所以未作详细注释回收分区当进程运行完毕释放内存时,系统根据回收区的首址,从空闲区链(表)中找到相应的插入点,此时可能出现以下四种情况之一;1)回收区与插入点的前一个空闲分区F1相邻接,此时应将回收区与插入点的前一分区合并,不必为回收区分配新表项,而只需修改其前一分区F1的大小.2)回收分区与插入点的后一空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和.3)回收区同时与插入点的前,后两个分区邻接,此时将三个分区合并,使用F1的表项和F1的首址,取消F2的表项,大小为三者之和.4)回收区既不与F1相邻接,又不与F2邻接.这时应为回收区单独建立一新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置.紧凑算法通过移动内存中的作业的位置,以把原来多个分散的小分区拼接成一个大分区的方法.第三章开发环境此程序是本人利用JAVA 语言在一种JCreator 的开发环境中实现的第四章重要算法和设计思路描述4.1 设计首次适应算法首先从内存分区的状态中找到空闲分区,若无空闲分区则不进行后面的运算,直接弹出对话框"内存中无空闲分区".把作业所需空间的大小与按始址大小,与各个空闲分区进行比较,如果某分区大小合适,把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区,然后对内存情况进行更新,每次分区小于作业，将指示不符合次数的n加一,如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项,最后对作业数组进行更新,把已运行的作业去除.4.2 设计循环首次适应算法同样根据内存分区的状态中找到空闲分区数组,令x指向上次找到空闲分区的下一个空闲分区,比较方法与首次适应算法相比，仅在此改为用x指示空闲分区在数组中的位置,每次查找空闲分区,都是从x后面那个分区开始查询, 如果某分区大小合适,把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区,然后对内存情况进行更新,每次分区小于作业，将指示不符合次数的n加一,到了数组末尾后再次进行循环回到数组头,一直寻找到上次所分配的位置,转为从首位开始查找后只比较到上一次找到的匹配分区，以保证循环可结束. 如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项,最后对作业数组进行更新,把已运行的作业去除.4.3 设计最佳适应算法和最坏适应算法最佳适应算法的实质就是对内存分区数组进行排序后,利用首次适应算法最坏适应算法的实质也是对内存分区数组排序后,进行首次适应算法,只不过它与最佳适应算法排序的方向刚好相反4.4 设计分区回收算法对内存分区状态进行查找,若回收区与插入点的前一个空闲分区F1相邻接,此时应将回收区与插入点的前一分区合并,不必为回收区分配新表项,而只需修改其前一分区F1的大小.若回收分区与插入点的后一空闲分区F2相邻接,此时也可将两分区合并,形成新的空闲分区,但用回收区的首址作为新空闲区的首址,大小为两者之和.若回收区同时与插入点的前,后两个分区邻接,此时将三个分区合并,使用F1的表项和F1的首址,取消F2的表项,大小为三者之和.若回收区既不与F1相邻接,又不与F2邻接.这时应为回收区单独建立一新表项,填写回收区的首址和大小,并根据其首址插入到空闲链中的适当位置4.5 设计紧凑算法同样对内存分区状态进行查找,若存在空闲分区,对分区数组,把已分配的数组的位置进行移动,使已分配的分区全部相邻,这样得到的最后剩下的一个大分区就是可以分配的分区啦.第五章程序实现---数据结构class memory{private int m1;//分区的序号private int m2;//分区的大小private int m3;//分区的起始地址private int m4;//是否已分配的标志} 这是定义的内存分区的结构class process{private int xuhao;//作业序号private int kongjian;//作业运行所需的空间} 这是定义的作业的结构第六章程序实现---程序清单import java.awt.event.*;import javax.swing.*;import java.awt.*;import java.io.*;import java.util.*;public class algorithm{private JFrame frame;private JTextPane memory;private JTextPane process;private memorydata md;private processdata pd;private int fitIndex=-1;private int select;private JTextField inputField;private JFrame inputFrame;public void go(){frame=new JFrame("动态分区");JPanel mainPanel=new JPanel();JPanel printPanel=new JPanel();printPanel.setLayout(new GridLayout(2, 1));memory=new JTextPane();process=new JTextPane();JScrollPane ScrollerM=new JScrollPane(memory);ScrollerM.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);ScrollerM.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);JScrollPane ScrollerP=new JScrollPane(process);ScrollerP.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS);ScrollerP.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);printPanel.add(ScrollerM);printPanel.add(ScrollerP);JMenuBar menuBar=new JMenuBar();JMenu fileMenu=new JMenu("文件");JMenu dataMenu=new JMenu("数据");JMenu FPMenu=new JMenu("分配");JMenu HSMenu=new JMenu("回收");JMenu JCMenu=new JMenu("紧凑");JMenuItem FileItemM=new JMenuItem("输出内存数据");JMenuItem FileItemP=new JMenuItem("输出作业数据");JMenuItem MemoryItem=new JMenuItem("读入内存数据");JMenuItem ProcessItem=new JMenuItem("读入作业数据");JMenuItem randomdataItemM=new JMenuItem("随机内存数据");JMenuItem randomdataItemP=new JMenuItem("随机作业数据");JMenuItem fenpeiItem=new JMenuItem("分配");JMenuItem huishouItem=new JMenuItem("回收");JMenuItem jinchouItem=new JMenuItem("紧凑");FileItemM.addActionListener(new OutputMemoryListener());FileItemP.addActionListener(new OutputProcessListener());MemoryItem.addActionListener(new InputMemoryListener());ProcessItem.addActionListener(new InputProcessListener());randomdataItemM.addActionListener(new randomMemoryListener());randomdataItemP.addActionListener(new randomProcessListener());fenpeiItem.addActionListener(new fenpeiListener());huishouItem.addActionListener(new huishouListener());jinchouItem.addActionListener(new jinchouListener());fileMenu.add(FileItemM);fileMenu.add(FileItemP);dataMenu.add(MemoryItem);dataMenu.add(ProcessItem);dataMenu.add(randomdataItemM);dataMenu.add(randomdataItemP);FPMenu.add(fenpeiItem);HSMenu.add(huishouItem);JCMenu.add(jinchouItem);menuBar.add(fileMenu);menuBar.add(dataMenu);menuBar.add(FPMenu);menuBar.add(HSMenu);menuBar.add(JCMenu);frame.setJMenuBar(menuBar);frame.getContentPane().add(BorderLayout.CENTER,printPanel);frame.setSize(600,500);frame.setVisible(true);}public class randomMemoryListener implements ActionListener{public void actionPerformed(ActionEvent ac){md=new memorydata();print.printM(md.m,memory);}}public class randomProcessListener implements ActionListener{ public void actionPerformed(ActionEvent ac){inputFrame=new JFrame();JPanel inputPanel=new JPanel();JButton sendButton=new JButton("确认");sendButton.addActionListener(new SendButtonListener3());inputField=new JTextField(10);inputPanel.add(inputField);inputPanel.add(sendButton);inputFrame.getContentPane().add(BorderLayout.CENTER,inputPanel);inputFrame.setSize(200,100);inputFrame.setLocationRelativeTo(null);inputFrame.setVisible(true);}}public class OutputMemoryListener implements ActionListener{ public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);MyFile.outputMemorydata(md,fileOpen.getSelectedFile());}}public class OutputProcessListener implements ActionListener{ public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);MyFile.outputProcessdata(pd,fileOpen.getSelectedFile());}}public class InputMemoryListener implements ActionListener{ public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);md=new memorydata(MyFile.inputMemorydata(fileOpen.getSelectedFile()));print.printM(md.m,memory);}}public class InputProcessListener implements ActionListener{public void actionPerformed(ActionEvent ac){JFileChooser fileOpen=new JFileChooser();fileOpen.showOpenDialog(frame);pd=new processdata(MyFile.inputProcessdata(fileOpen.getSelectedFile()));print.printP(pd.p,process);}}public class fenpeiListener implements ActionListener{public void actionPerformed(ActionEvent ac){fenpeiProcess();}}public class huishouListener implements ActionListener{public void actionPerformed(ActionEvent ac){if(!memorydata.huishou(md.m)){JOptionPane.showMessageDialog(frame, "内存中无可回收分区");return;}waitinput();}}public class jinchouListener implements ActionListener{public void actionPerformed(ActionEvent ac){if(!memorydata.kongxian(md.m)){JOptionPane.showMessageDialog(frame, "内存中分区全被分配,无空闲分区");return;}jincou();}}public class SendButtonListener3 implements ActionListener{public void actionPerformed(ActionEvent ev){int processmount=Integer.parseInt(inputField.getText());pd=new processdata(processmount);print.printP(pd.p,process);}}public class SendButtonListener2 implements ActionListener{public void actionPerformed(ActionEvent ev){int selectmemory=Integer.parseInt(inputField.getText());recycle(selectmemory);}}public class SendButtonListener implements ActionListener{public void actionPerformed(ActionEvent ev){int selectProcess=Integer.parseInt(inputField.getText());if(select!=1&&select!=2&&select!=3&&select!=4){JOptionPane.showMessageDialog(inputFrame, "请选择一种分配方法");return;}if(selectProcess>pd.p.length){JOptionPane.showMessageDialog(inputFrame, "输入错误");return;}if(select==1){FirstFit(selectProcess);}else if(select==2){fitIndex=NextFit(selectProcess,fitIndex);}else if(select==3){BestFit(selectProcess);}else if(select==4){WorstFit(selectProcess);}}}public class b1ButtonListener implements ActionListener{public void actionPerformed(ActionEvent ev){select=1;}}public class b2ButtonListener implements ActionListener{ public void actionPerformed(ActionEvent ev){select=2;}}public class b3ButtonListener implements ActionListener{ public void actionPerformed(ActionEvent ev){select=3;}}public class b4ButtonListener implements ActionListener{ public void actionPerformed(ActionEvent ev){select=4;}}private void waitinput(){inputFrame=new JFrame();JPanel inputPanel=new JPanel();JButton sendButton=new JButton("确认");sendButton.addActionListener(new SendButtonListener2());inputField=new JTextField(10);inputPanel.add(inputField);inputPanel.add(sendButton);inputFrame.getContentPane().add(BorderLayout.CENTER,inputPanel);inputFrame.setSize(200,100);inputFrame.setLocationRelativeTo(null);inputFrame.setVisible(true);}private void fenpeiProcess(){inputFrame=new JFrame();JRadioButton b1 = new JRadioButton();JRadioButton b2 = new JRadioButton();JRadioButton b3 = new JRadioButton();JRadioButton b4 = new JRadioButton();ButtonGroup group = new ButtonGroup();JPanel intro = new JPanel();JLabel introJl = new JLabel();intro.add(introJl);introJl.setText(" 分配算法选择 ");inputFrame.add(intro);b1.setText("1、首次适应算法");b2.setText("2、循环首次适应算法");b3.setText("3、最佳适应算法");b4.setText("4、最坏适应算法");b1.addActionListener(new b1ButtonListener());b2.addActionListener(new b2ButtonListener());b3.addActionListener(new b3ButtonListener());b4.addActionListener(new b4ButtonListener());group.add(b1);group.add(b2);group.add(b3);group.add(b4);// p为第二个JPanelJPanel p = new JPanel();// 设置第二个JPanel上的jl1 JLabel初始显示信息JLabel jl1 = new JLabel();jl1.setText("输入待分配的作业序号");// 添加该JLabel到p上p.add(jl1);// 添加该JPanelinputFrame.add(p);// p1为第三个Panel，此JPanel由于要显示5个算法的单选键，所以设置为5行的GridLayout布局JPanel p1 = new JPanel();p1.setLayout(new GridLayout(4, 1));p1.add(b1);p1.add(b2);p1.add(b3);p1.add(b4);inputFrame.add(p1);JPanel inputPanel=new JPanel();inputField=new JTextField(5);inputPanel.add(inputField);JButton sendButton=new JButton("确认");sendButton.addActionListener(new SendButtonListener());inputPanel.add(sendButton);inputFrame.add(inputPanel);inputFrame.setLayout(new FlowLayout());// 设置窗口大小，inputFrame.setSize(400, 220);// 大小不可更改inputFrame.setLocation(300, 400);// 显示inputFrame.setVisible(true);// 设置窗口右上角的关闭按钮事件为结束程序inputFrame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);}/*** 首次适应算法* 算法概述：分配内存时，从链首开始顺序查找，找到满足的空闲分区则划出空间分配，余下的空闲空间仍保留在空闲链表中* 实现方法：分配时从数组第一个元素开始比较，若符合条件则将该元素减去对应作业的值**/private void FirstFit(int selectProcess){print.printM(md.m,memory);//显示当前内存分区状况memory[] free=memorydata.Free(md.m);//对当前内存分区获取空闲分区的信息print.printF(free,memory);//显示内存空闲分区的状况print.insert("首次适应算法",memory);int xuhao=selectProcess-1;if (free.length == 0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");}else{int n=0;//指示分区与作业不符合的次数for(int j=0;j<free.length;j++){//与各个空闲分区进行比较print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区大小为["+pd.p[xuhao].getkongjian()+"] 与分区号为"+free[j].getm1()+"的空闲分区 ["+free[j].getm2()+"] 比较",memory);if(pd.p[xuhao].getkongjian()<free[j].getm2()){//分区大于作业print.insert("符合，分配",memory);memory[] nb=new memory[md.m.length+1];int ni=free[j].getm1();if(free[j].getm1()==1){//如果该空闲分区是内存表头//把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区nb[0]=new memory(1,pd.p[xuhao].getkongjian(),0,1);nb[1]=newmemory(2,free[j].getm2()-pd.p[xuhao].getkongjian(),pd.p[xuhao].getkongjian(),0);//把nb构造成经过分配后的内存分区数组for(int k=2;k<nb.length;k++)nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());md.m=nb;print.printM(md.m,memory);free= memorydata.Free(md.m);print.printF(free,memory);}else{//如果该空闲分区不是内存表头for(int k=0;k<ni;k++)nb[k]=newmemory(md.m[k].getm1(),md.m[k].getm2(),md.m[k].getm3(),md.m[k].getm4());//把该分区一分为二,前部为已经分配出去的分区,后者为剩余的分区nb[ni-1].setm2(pd.p[0].getkongjian());nb[ni-1].setm4(1);//设置标识此分区已分配nb[ni]=newmemory(nb[ni-1].getm1()+1,free[j].getm2()-pd.p[xuhao].getkongjian(),nb[ni-1].getm2()+nb[ni-1].get m3(),0);for(int k=ni+1;k<nb.length;k++){nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());}md.m=nb;print.printM(md.m,memory);free = memorydata.Free(md.m);print.printF(free,memory);}break;}else{if(pd.p[xuhao].getkongjian()==free[j].getm2()){//分区等于作业print.insert(" 符合，分配",memory);md.m[free[j].getm1()-1].setm4(1);//把此分区标志位已分配print.printM(md.m,memory);free= memorydata.Free(md.m);print.printF(free,memory);break;}else{//分区小于作业，将指示不符合次数的n加一n++;}}if(n==free.length){//如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "无符合分区");//print.insert(" 无符合分区",memory);return;}}//对作业数组进行更新,把已运行的作业去除processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);}}/*** 循环首次适应算法* 算法概述：由首次适应算法演变，只是每次分配改为由上一次找到的空闲分区开始查找* 实现方法：在首次适应算法的基础上增加一个值用于记录找到的空闲分区的位置**///此函数返回记录找到的空闲分区的位置private int NextFit(int input,int fitIndex){print.printM(md.m,memory);memory[] free=memorydata.Free(md.m);//构造空闲分区print.printF(free,memory);print.insert("循环首次适应算法",memory);int xuhao=input-1;if(free.length==0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");//print.insert("内存中无空闲区",memory);return fitIndex;}else{int n = 0;//指示分区与作业不符合的次数print.insert(" - - - - - - - - - - - - - - - - - - - - - - - - -",memory);int x = fitIndex + 1;// 令x指向上次找到空闲分区的下一个空闲分区// 比较方法与首次适应算法相比，仅在此改为用x指示空闲分区在数组中的位置while (x <md.m.length){if (md.m[x].getm4() != 1){print.insert(" 进程号"+pd.p[xuhao].getxuhao()+" 所需分区["+pd.p[xuhao].getkongjian()+"] 与分区号为"+md.m[x].getm1()+"的空闲分区 ["+md.m[x].getm2()+"] 比较，",memory);if (pd.p[xuhao].getkongjian()<md.m[x].getm2()){// 假如作业小于空闲分区，则可分配print.insert("符合，分配",memory);memory[] nb =new memory[md.m.length + 1];for (int k = 0; k < x; k++){nb[k] =md.m[k];}// 数组对应元素减去作业大小，即表示分配后的大小int size = md.m[x].getm2()-pd.p[xuhao].getkongjian();nb[x] = md.m[x];nb[x].setm2(pd.p[xuhao].getkongjian());nb[x].setm4(1); //标志此分区为已分配nb[x + 1]=new memory(nb[x].getm1() + 1,size,nb[x].getm2()+ nb[x].getm3(), 0);//创建分配后余下的分区for(int k = x + 2; k < nb.length; k++){nb[k] = md.m[k - 1];nb[k].setm1(nb[k].getm1()+1);}md.m=nb;fitIndex = x;//更新此次找到的空闲分区的位置print.printM(md.m,memory);free=memorydata.Free(md.m);print.printF(free,memory);// 得到分配，结束此作业比较循环break;}else{if(pd.p[xuhao].getkongjian()==md.m[x].getm2()){//分区等于作业print.insert(" 符合，分配",memory);md.m[md.m[x].getm1()-1].setm4(1);//标志此分区为已分配print.printM(md.m,memory);free= memorydata.Free(md.m);print.printF(free,memory);fitIndex = x;//更新此次找到的空闲分区的位置break;}else{n++;// 每不符一次把n加1print.insert("不符，往下找",memory);}}}x++;// 利用x++将元素指向下一位}//到了数组末尾后再次进行循环回到数组头if (x >= md.m.length){x = 0;while (x <= fitIndex) //一直寻找到上次所分配的位置{if (md.m[x].getm4()!= 1){// 转为从首位开始查找后只比较到上一次找到的匹配分区，以保证循环可结束print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区["+pd.p[xuhao].getkongjian()+"] 与分区号为"+md.m[x].getm1()+"的空闲分区 ["+md.m[x].getm2()+"] 比较，",memory);if (pd.p[xuhao].getkongjian()<md.m[x].getm2()){// 假如作业小于空闲分区，则可分配print.insert("符合，分配",memory);memory[] nb =new memory[md.m.length + 1];for (int k = 0; k < x; k++){nb[k] =md.m[k];}// 数组对应元素减去作业大小，即表示分配后的大小int size = md.m[x].getm2()-pd.p[xuhao].getkongjian();nb[x] =md.m[x];nb[x].setm2(pd.p[xuhao].getkongjian());nb[x].setm4(1);nb[x + 1] = new memory(nb[x].getm1() + 1, size,nb[x].getm2()+ nb[x].getm3(), 0);for (int k = x + 2; k < nb.length; k++){nb[k] =md.m[k - 1];nb[k].setm1(nb[k].getm1()+1);}md.m=nb;fitIndex = x;print.printM(md.m,memory);free = memorydata.Free(md.m);print.printM(free,memory); // 得到分配，结束此作业比较循环break;}else{if(pd.p[xuhao].getkongjian()==md.m[x].getm2()){//分区等于作业print.insert(" 符合，分配",memory);md.m[md.m[x].getm1()-1].setm4(1);print.printM(md.m,memory);free = memorydata.Free(md.m);print.printM(free,memory);fitIndex = x;break;}else{n++;// 每不符一次把n加1print.insert("不符，往下找",memory);}}}x++; // 利用x++将元素指向下一位}}if (n == free.length){// 假如n等于空闲数组的长度，则说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "未找到符合的空闲分区");//print.insert("",memory);//print.insert(" 未找到符合的空闲分区",memory);return fitIndex;}else{//对作业数组进行更新processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);System.out.println();return fitIndex;}}}/** 最佳适应算法* 算法概述：每次为作业分配内存时，总是把能满足要求、又是最小的空闲分区分配给作业* 实现方法：我们决定每次分配先把空闲分区按从小到大的顺序排列，然后将第一个匹配分区分配给作业 **///最佳适应算法的实质就是对内存分区数组进行排序后,利用首次适应算法private void BestFit(int input){print.printP(pd.p,process);print.printM(md.m,memory);memory[] free=memorydata.Free(md.m);memorydata.up(free);//对内存数组进行排序print.printF(free,memory);//后面的比较过程与首次适应算法一样print.insert("最佳适应算法",memory);int xuhao=input-1;if (free.length == 0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");//print.insert("内存中无空闲分区",memory);}else{int n=0;for(int j=0;j<free.length;j++){//与各个空闲分区进行比较print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区大小为["+pd.p[xuhao].getkongjian()+"] 与分区号为"+free[j].getm1()+"的空闲分区 ["+free[j].getm2()+"] 比较",memory);if(pd.p[xuhao].getkongjian()<free[j].getm2()){//分区大于作业print.insert("符合，分配",memory);memory[] nb=new memory[md.m.length+1];int ni=free[j].getm1();if(free[j].getm1()==1){//如果该空闲分区是内存表头nb[0]=new memory(1,pd.p[xuhao].getkongjian(),0,1);nb[1]=newmemory(2,free[j].getm2()-pd.p[xuhao].getkongjian(),pd.p[xuhao].getkongjian(),0);for(int k=2;k<nb.length;k++)nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());md.m=nb;print.printM(md.m,memory);free= memorydata.Free(md.m);memorydata.up(free);print.printF(free,memory);}else{//如果该空闲分区不是内存表头for(int k=0;k<ni;k++)nb[k]=newmemory(md.m[k].getm1(),md.m[k].getm2(),md.m[k].getm3(),md.m[k].getm4());nb[ni-1].setm2(pd.p[0].getkongjian());nb[ni-1].setm4(1);nb[ni]=newmemory(nb[ni-1].getm1()+1,free[j].getm2()-pd.p[xuhao].getkongjian(),nb[ni-1].getm2()+nb[ni-1].get m3(),0);for(int k=ni+1;k<nb.length;k++){nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());}md.m=nb;print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.up(free);print.printF(free,memory);}break;}else{if(pd.p[xuhao].getkongjian()==free[j].getm2()){//分区等于作业System.out.println(" 符合，分配");md.m[free[j].getm1()-1].setm4(1);print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.up(free);print.printF(free,memory);break;}else{//分区小于作业，将指示不符合次数的n加一n++;}}if(n==free.length){//如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "无符合分区");//print.insert(" 无符合分区",memory);return;}}processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);}}/** 最坏适应算法* 算法概述：每次为作业分配内存时，总是挑选一个最大的空闲分区分割给作业使用* 实现方法：算法与最佳适应算法几乎相同，仅在排序时把空闲分区表按从大到小的顺序排列，所以未作详细注释**///最坏适应算法的实质也是对内存分区数组排序后,进行首次适应算法,只不过它与最佳适应算法排序的方向刚好相反private void WorstFit(int input){print.printP(pd.p,process);print.printM(md.m,memory);memory[] free=memorydata.Free(md.m);memorydata.down(free);//对内存数组进行排序print.printF(free,memory);//后面的比较过程与首次适应算法一样print.insert("最坏适应算法",memory);int xuhao=input-1;if (free.length == 0){// 若无空闲分区则不进行后面的运算JOptionPane.showMessageDialog(frame, "内存中无空闲分区");//print.insert("内存中无空闲分区",memory);}else{int n=0;for(int j=0;j<free.length;j++){//与各个空闲分区进行比较print.insert("进程号"+pd.p[xuhao].getxuhao()+" 所需分区大小为["+pd.p[xuhao].getkongjian()+"] 与分区号为"+free[j].getm1()+"的空闲分区 ["+free[j].getm2()+"] 比较",memory);if(pd.p[xuhao].getkongjian()<free[j].getm2()){//分区大于作业print.insert("符合，分配",memory);memory[] nb=new memory[md.m.length+1];int ni=free[j].getm1();if(free[j].getm1()==1){//如果该空闲分区是内存表头nb[0]=new memory(1,pd.p[xuhao].getkongjian(),0,1);nb[1]=newmemory(2,free[j].getm2()-pd.p[xuhao].getkongjian(),pd.p[xuhao].getkongjian(),0);for(int k=2;k<nb.length;k++)nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());md.m=nb;print.printM(md.m,memory);free= memorydata.Free(md.m);memorydata.down(free);print.printF(free,memory);}else{//如果该空闲分区不是内存表头for(int k=0;k<ni;k++)nb[k]=newmemory(md.m[k].getm1(),md.m[k].getm2(),md.m[k].getm3(),md.m[k].getm4());nb[ni-1].setm2(pd.p[0].getkongjian());nb[ni-1].setm4(1);nb[ni]=newmemory(nb[ni-1].getm1()+1,free[j].getm2()-pd.p[xuhao].getkongjian(),nb[ni-1].getm2()+nb[ni-1].get m3(),0);for(int k=ni+1;k<nb.length;k++){nb[k]=newmemory(nb[k-1].getm1()+1,md.m[k-1].getm2(),nb[k-1].getm2()+nb[k-1].getm3(),md.m[k-1].getm4());}md.m=nb;print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.down(free);print.printF(free,memory);}break;}else{if(pd.p[xuhao].getkongjian()==free[j].getm2()){//分区等于作业System.out.println(" 符合，分配");md.m[free[j].getm1()-1].setm4(1);print.printM(md.m,memory);free = memorydata.Free(md.m);memorydata.down(free);print.printF(free,memory);break;}else{//分区小于作业，将指示不符合次数的n加一n++;}}if(n==free.length){//如果不符合次数为空闲分区数组长度，说明找遍空闲分区都无符合项JOptionPane.showMessageDialog(frame, "无符合分区");//print.insert(" 无符合分区",memory);return;}}processdata temp=new processdata(pd.p.length-1);for(int i=0;i<xuhao;i++)temp.p[i].setkongjian(pd.p[i].getkongjian());for(int i=xuhao;i<temp.p.length;i++){int te=pd.p[i+1].getkongjian();temp.p[i].setkongjian(te);}pd.p=temp.p;print.printP(pd.p,process);}}//回收已分配的分区private void recycle(int a){memory[] nm;if(md.m[a-1].getm4()==0){JOptionPane.showMessageDialog(frame, "该分区为空闲");//print.insert("该分区为空闲",memory);return;}if (a == 1){// 假如是内存表头if (md.m[a].getm4() == 0){// 假如第二块是空闲分区，则与第二块合并，起址为该回收块起址，其它各项仅修改序号nm =new memory[md.m.length-1];nm[a - 1] = md.m[a - 1];nm[a - 1].setm4(0);nm[a - 1].setm2(nm[a - 1].getm2()+md.m[1].getm2());for (int i = 1; i < nm.length; i++){nm[i] = md.m[i + 1];nm[i].setm1(nm[i].getm1()-1);}}else{// 假如第二块不是空闲分区，则单独建立一个空闲分区md.m[0].setm4(0);nm = md.m;}}else{if (a == md.m.length){// 假如是内存表末if (md.m[a - 2].getm4()== 0){// 假如倒数第二块是空闲分区，则与倒数第二块合并，起址为该回收块起址，其它各项仅修改序号nm =new memory[md.m.length - 1];nm[a - 2] = md.m[a - 2];nm[a - 2].setm4(0);nm[a - 2].setm2(nm[a - 2].getm2()+md.m[a - 1].getm2());for (int i = 0; i < nm.length - 1; i++){nm[i] = md.m[i];}}else{// 假如倒数第二块不是空闲分区，则单独建立一个空闲分区md.m[a - 1].setm4(0);nm =md.m;}}else{// 假如不是第一块也不是最后一块，则有四种情况if (md.m[a - 2].getm4() == 0 && md.m[a].getm4() == 0){// 夹在两块空闲分区中间// 建立少两个单位的新数组，存储到该回收区的前两位nm = new memory[md.m.length - 2];for (int i = 0; i < a - 2; i++){nm[i] = md.m[i];}// 将回收区前一位的大小改为这三个分区的和，然后将后面的元素前移两位，序号也相应减去2nm[a - 2] =md.m[a - 2];nm[a - 2].setm2(nm[a - 2].getm2()+md.m[a - 1].getm2() + md.m[a].getm2());for (int i = a - 1; i < nm.length; i++){nm[i] =md.m[i + 2];nm[i].setm1(nm[i].getm1()-2);}}else{if (md.m[a - 2].getm4() == 0){// 前一块是空闲分区// 建立少一个单位的新数组用于存储，将回收区的大小加至前一块空闲分区，后面的元素依次前移一位，序号减一nm = new memory[md.m.length - 1];for (int i = 0; i < a - 2; i++){nm[i] = md.m[i];}nm[a - 2] = md.m[a - 2];nm[a - 2].setm2(nm[a - 2].getm2()+md.m[a - 1].getm2());for (int i = a - 1; i < nm.length; i++){nm[i] = md.m[i + 1];nm[i].setm1(nm[i].getm1()-1);}}else{if (md.m[a].getm4() == 0){// 后一块是空闲分区nm = new memory[md.m.length - 1];// 前面元素不变，将后面的空闲分区大小加至该分区，然后把后面的元素前移一位，序号减一for (int i = 0; i < a - 1; i++){nm[i] = md.m[i];}nm[a - 1] = md.m[a - 1];nm[a - 1].setm4(0);nm[a - 1].setm2(nm[a - 1].getm2()+md.m[a].getm2());for ( int i = a; i < nm.length; i++){nm[i] =md.m[i + 1];nm[i].setm1(nm[i].getm1()-1);}}else{// 前后都是已分配的分区，直接修改分配状态md.m[a - 1].setm4(0);nm = md.m;}}}}}md.m=nm;// 将代表内存现在状态的nm数组返回print.printM(md.m,memory);}//对内存实行紧凑算法private void jincou(){memory[] temp=new memory[md.m.length];memory[] result;int index=0,value=0;//分别把内存中已经被分配的分区移动位置,使他们相邻for(int i=0;i<md.m.length;i++){if(md.m[i].getm4()==1){temp[index++]=new memory(index,md.m[i].getm2(),value,1);value+=md.m[i].getm2();}}if(value!=512){temp[index++]=new memory(index,512-value,value,0);//把最后剩下的内存空间建立一个完整的空闲分区}result=new memory[index];。

三．算法流程图图1－1 主程序流程图图1－2 FCFS算法流程图图1－3 RR算法流程图图1－4 HPF算法流程图四．源程序及注释----------------------------------------------pcbobj.h ---------------------------------------------#include <string>using namespace std;#ifndef PCBOBJ_H_#define PCBOBJ_H_enum pStatus{Wait,Run,Finish,UNGO};//定义进程的四种状态class PCBobj {public:PCBobj();PCBobj(string name,int id,int reach,int execute);virtual ~PCBobj();int getExecTime() const;int getHasExecTime() const;int getId() const;int getReachTime() const;string getName() const;pStatus getStatus() const;void setHasExecTime(int hasExecTime);void setId(int pId);void setStatus(pStatus status);void setExecTime(int execTime);void setName(string pName);void setReachTime(int reachTime);bool isFinish();//进程是否运行完毕bool last_statu;//判断进程上一个cpu是否是运行态private:string pName; //进程名int pId; //进程优先数int reachTime; //进程到达时间int execTime; //进程需要运行的时间int hasExecTime; //进程已经运行的时间pStatus status;};typedef PCBobj *pcbobj;#endif /* PCBOBJ_H_ */-------------------------------------------pcbobj.cpp代码------------------------------------------------ #include "PCBobj.h"PCBobj::PCBobj() {hasExecTime=0;status=UNGO;last_statu=false;}PCBobj::PCBobj(string name,int id,int reach,int execute){ pName=name;pId=id;reachTime=reach;execTime=execute;hasExecTime=0;status=UNGO;}PCBobj::~PCBobj() {}int PCBobj::getExecTime() const{return execTime;}int PCBobj::getHasExecTime() const{return hasExecTime;}int PCBobj::getId() const{return pId;}string PCBobj::getName() const{return pName;}int PCBobj::getReachTime() const{return reachTime;}pStatus PCBobj::getStatus() const{return status;}void PCBobj::setHasExecTime(int hasExecTime){ this->hasExecTime = hasExecTime;}void PCBobj::setId(int pId){this->pId = pId;}void PCBobj::setStatus(pStatus status){this->status = status;}void PCBobj::setExecTime(int execTime){this->execTime = execTime;}void PCBobj::setName(string pName){this->pName = pName;}void PCBobj::setReachTime(int reachTime){this->reachTime = reachTime;}bool PCBobj::isFinish(){bool Flag=false;if(execTime == hasExecTime){status=Finish;Flag=true;}return Flag;}-----------------------------------------------waitmanager.h------------------------------#include<iostream>#include <list>#include"PCBobj.h"#ifndef WAITMANAGER_H_#define WAITMANAGER_H_class WaitManager {public:WaitManager();virtual ~WaitManager();void add(pcbobj new_obj);void insert(pcbobj new_name);void remove(string name);void remove();bool empty();pcbobj get();pcbobj last();private:list<pcbobj> wait_PCB_list;};#endif /* WAITMANAGER_H_ */-------------------------------------------waitmanager.cpp----------------------------------- #include "WaitManager.h"WaitManager::WaitManager() {}WaitManager::~WaitManager() {}void WaitManager::add(pcbobj new_obj){wait_PCB_list.push_back(new_obj);new_obj->setStatus(Wait);}bool WaitManager::empty(){return wait_PCB_list.empty();}void WaitManager::insert(pcbobj new_obj){if(wait_PCB_list.empty()){add(new_obj);}else{bool insert_info=false;//查看是否已经插入进去for(list<pcbobj>::iterator it=wait_PCB_list.begin();it!=wait_PCB_list.end();it++){ if(new_obj->getId()>(*it)->getId()){wait_PCB_list.insert(it,new_obj);new_obj->setStatus(Wait);insert_info=true;break;}}if(!insert_info){wait_PCB_list.push_back(new_obj);new_obj->setStatus(Wait);}}}void WaitManager::remove(string name){if(empty()){cout<<"没有进程在就绪队列中"<<endl;}else{bool remove_info=false;for(list<pcbobj>::iterator it=wait_PCB_list.begin();it!=wait_PCB_list.end();it++){ if((*it)->getName() == name){wait_PCB_list.erase(it);remove_info=true;break;}}if(!remove_info){cout<<name<<"进程"<<"不存在"<<endl;}}}void WaitManager::remove(){if(empty()){cout<<"没有就绪进程在队列中"<<endl;}else{wait_PCB_list.pop_front();}}pcbobj WaitManager::get(){return wait_PCB_list.front();}pcbobj WaitManager::last(){return wait_PCB_list.back();}------------------------------------------------------cpumanager.h---------------------- #include "PCBobj.h"#ifndef CPU_MANAGER_H_#define CPU_MANAGER_H_enum cpu_Status{FREE,BUSY};//cpu的状态class cpu_Manager {public:cpu_Manager();virtual ~cpu_Manager();void remove();cpu_Status getCpu_info() const;pcbobj getCpu_pcb() const;void add(pcbobj cpu_pcb);void update();void update(int args);int cpu_timeslice;private:cpu_Status cpu_info;pcbobj cpu_pcb;};#endif /* CPU_MANAGER_H_ */---------------------------------------------------cpumanager.cpp-------------------- #include "cpu_Manager.h"cpu_Manager::cpu_Manager() {cpu_pcb=0;cpu_info=FREE;cpu_timeslice=4;}cpu_Manager::~cpu_Manager() {cpu_pcb=0;}cpu_Status cpu_Manager::getCpu_info() const{return cpu_info;}pcbobj cpu_Manager::getCpu_pcb() const{return cpu_pcb;}void cpu_Manager::add(pcbobj cpu_pcb1){cpu_pcb = cpu_pcb1;cpu_info=BUSY;}void cpu_Manager::remove(){this->cpu_pcb=0;cpu_info=FREE;}void cpu_Manager::update(){cpu_pcb->setStatus(Run);cpu_pcb->setHasExecTime(cpu_pcb->getHasExecTime()+1);}void cpu_Manager::update(int args){update();cpu_pcb->setId(cpu_pcb->getId()- args);}---------------------------------------------------- schedul_simulate.h-----------------#include "WaitManager.h"#include "cpu_Manager.h"#ifndef SCHEDUL_SIMULATE_H_#define SCHEDUL_SIMULATE_H_void choice();string convert_statu(pStatus statu);void process_init(pcbobj process);void process_update(pcbobj process,int time_record,WaitManager& wait_manager); void process_update_id(pcbobj process,int time_record,WaitManager& wait_manager); //--------打印进程信息---------------void process_record(pcbobj process,int time_record);//----------从wait到run------------void waitTOrun(WaitManager& wait_manager,cpu_Manager& cpu_manager);void runTOwait(WaitManager& wait_manager,cpu_Manager& cpu_manager);void FCFS(pcbobj process);void RR(pcbobj process);void HPF(pcbobj process);#endif /* SCHEDUL_SIMULATE_H_ */------------------------------------------- schedul_simulate.cpp-------------------------------#include"schedul_simulate.h"void choice(){cout<<"1:FCFS"<<endl;cout<<"2:RR"<<endl;cout<<"3:HPF"<<endl;cout<<"4:quit"<<endl;}string convert_statu(pStatus statu) {string value = "UNGO";switch (statu) {case Wait:value = "Wait";break;case Run:value = "Run";break;case Finish:value = "Finish";break;case UNGO:value = "UNGO";}return value;}void process_init(pcbobj process) {string name;int process_id;int process_reach;int process_execute;cout << "请按顺序输入进程的唯一标识---进程名进程的优先级进程的到达时间进程的运行时间" << endl;for (int i = 0; i < 4; i++) {//process里的hasExecTime和status已经被初始化cout << "请输入第" << (i + 1) << "个进程的信息" << endl;cin >> name;cin >> process_id;cin >> process_reach;cin >> process_execute;(process + i)->setName(name);(process + i)->setId(process_id);(process + i)->setReachTime(process_reach);(process + i)->setExecTime(process_execute);cout << "第" << (i + 1) << "个进程信息已经初始化" << endl;}cout << "所有进程信息已经全部完成" << endl;}void process_update(pcbobj process, int time_record, WaitManager& wait_manager) { for (int i = 0; i < 4; i++) {if ((process + i)->getReachTime() == time_record) {wait_manager.add((process + i));//直接加到末尾}}}void process_update_id(pcbobj process, int time_record, WaitManager& wait_manager) {for (int i = 0; i < 4; i++) {if ((process + i)->getReachTime() == time_record) {wait_manager.insert((process + i));}}}void process_record(pcbobj process,int time_record){cout << "时刻:" << time_record << endl;cout << "进程名\t优先数\t到达时间\t运行时间\t已经运行时间\t状态" << endl;cout << "----------------------------------------------------------"<< endl;for (int i = 0; i < 4; i++) {cout << (process + i)->getName() << "\t"<< (process + i)->getId() <<"\t"<< (process + i)->getReachTime() << "\t"<< (process + i)->getExecTime() << "\t"<< (process + i)->getHasExecTime() << "\t\t";if((process+i)->last_statu)cout<< convert_statu(Run) << endl;elsecout<<convert_statu((process+i)->getStatus())<<endl;(process+i)->last_statu=false;}cout << "----------------------------------------------------------"<< endl;}void waitTOrun(WaitManager& wait_manager, cpu_Manager& cpu_manager) { cpu_manager.add(wait_manager.get());wait_manager.remove();}void runTOwait(WaitManager& wait_manager, cpu_Manager& cpu_manager) { pcbobj temp=cpu_manager.getCpu_pcb();temp->last_statu=true;wait_manager.add(temp);}void FCFS(pcbobj process) {int time_record = 0;PCBobj *process_last = process + 3;WaitManager wait_manager;cpu_Manager cpumanager;while (process_last->getStatus() != Finish) {process_update(process,time_record,wait_manager);process_record(process,time_record);if (!wait_manager.empty() && cpumanager.getCpu_info() == FREE){waitTOrun(wait_manager, cpumanager);}if (cpumanager.getCpu_info() == BUSY){cpumanager.update();if(cpumanager.getCpu_pcb()->isFinish())cpumanager.remove();}time_record++;if (process_last->getStatus() != UNGO && !wait_manager.empty())//已经到达{ process_last = wait_st();}}process_record(process,time_record);}void RR(pcbobj process) {int time_record = 0;PCBobj *process_last = process + 3;WaitManager wait_manager;cpu_Manager cpumanager;int k=0;//记录时间片满则为零while (process_last->getStatus() != Finish) {process_update(process,time_record,wait_manager);process_record(process,time_record);if (!wait_manager.empty() && cpumanager.getCpu_info() == FREE){waitTOrun(wait_manager, cpumanager);}if (cpumanager.getCpu_info() == BUSY){cpumanager.update();k++;if (cpumanager.getCpu_pcb()->isFinish()){cpumanager.remove();k=0;}else if(k>=cpumanager.cpu_timeslice){runTOwait(wait_manager,cpumanager);cpumanager.remove();k=0;}}time_record++;if (process_last->getStatus() != UNGO && !wait_manager.empty())//已经到达{ process_last = wait_st();}}process_record(process,time_record);}void HPF(pcbobj process) {int time_record = 0;PCBobj *process_last = process + 3;WaitManager wait_manager;cpu_Manager cpumanager;pcbobj temp;while (process_last->getStatus() != Finish) {process_update_id(process,time_record,wait_manager);process_record(process,time_record);if (!wait_manager.empty() && cpumanager.getCpu_info() == FREE){waitTOrun(wait_manager, cpumanager);}if (cpumanager.getCpu_info() == BUSY){cpumanager.update(1);if (!cpumanager.getCpu_pcb()->isFinish()) {temp=cpumanager.getCpu_pcb();temp->last_statu=true;wait_manager.insert(temp);}cpumanager.remove();}time_record++;if (process_last->getStatus() != UNGO && !wait_manager.empty())//已经到达{ process_last = wait_st();}}process_record(process,time_record);}------------------------------------------------------main.cpp------------------------------------#include"schedul_simulate.h"int main(){int you_choice;PCBobj obj[4];process_init(&obj[0]);choice();bool start_app=true;while(start_app){cin>>you_choice;switch(you_choice){case 1:FCFS(&obj[0]);break;case 2:RR(&obj[0]);break;case 3:HPF(&obj[0]);break;case 4:start_app=false;}}return 0;}五．运行结果及分析图1－5 进程信息初始化图1－6 选择时间片算法调度图1－7 开始只有a进程进入就绪队列，运行a进程图1－8 a运行完毕，b,c都已经到达，此时运行b进程图1－9 b运行完毕时，此时c,d都已经完成，运行c进程图1－10 c的时间片已经完成，将c放入到就绪队列，d进程开始运行图1－11 d运行完毕继续运行c进程,直到运行完毕六．课程设计总结通过这次操作系统的课程设计，我研究了进程调度的相关知识。