操作系统算法设计操作系统课程设计大学论文

合集下载

操作系统课程设计(小型的操作系统)

操作系统课程设计报告题目：一个小型的操作系统班级：计122（杏）学号：1213023075姓名：贾苏日期：2014/06/231.实验平台（1）软件平台：开发系统平台：Windows 7 （64）Microsoft visual c++ 6.0测试系统平台：Windows 7 （64）（2）硬件平台：cpu：AMD A6-3420 APU内存：4GB硬盘：500G2.所需实现的功能及相应的阐述：（1）进程调度管理为了贴切现实中的os，采用RR（轮转调度算法），且不提供用户显式的选择调度算法，即对用户是透明的。

现实中的处理器主频为1Ghz~3Ghz，选取中间点为1.5Ghz，得时间片大小为0.7ns ，为方便计算*10，则时间片大小定为7ns。

假设进程之间的调度和切换不耗费cpu时间。

（2）死锁的检测与处理检测当然采用的是银行家算法处理：让用户选择kill一个进程，释放他所占有的所有资源。

（3）虚拟分页调度管理虚拟分页：给出的是逻辑值访问磁盘将那个数据块放入到内存中内存中的地址采用一定的算法相对应于磁盘的地址。

特规定访存采用的是按字节寻址内存的大小128KB外存的大小1MB即整个系统可以提供1MB的逻辑地址空间供进程进行访问（在地址总线足够扫描内存的情况下）。

虚拟地址映射采用：直接映射法规定的8kB为一个页面，故内存有16个页面，外存有128个页面。

如果产生了内存已满，便会产生缺页中断，淘汰采用FIFO算法，利用一个队列来做。

部分内外存的对应表0 0，128，2*128+0.......1 1，129，2*128+1.......2 2，130，2*128+2.......16 127，128+16,2*128+16.........（4）I/O中断处理设中断来自两个方面：1.DMA输送开始和结束时的中断设定一个宏定义为DMA一次传输的数据量的大小->DmaNum 假定为10kb每次DMA开始：耗费1ns cpu时间进行中断处理DMA 结束：耗费2ns cpu 时间进行中断处理由操作系统课程知，DMA 传输数据时不需要CPU 的干预。

《操作系统》课程设计

《操作系统》课程设计一、课程目标知识目标：1. 让学生掌握操作系统的基本概念，包括进程、线程、内存管理、文件系统等核心知识；2. 了解操作系统的历史发展，掌握不同类型操作系统的特点及使用场景；3. 掌握操作系统的性能评价方法和常用的调度算法。

技能目标：1. 培养学生运用操作系统知识解决实际问题的能力，如分析系统性能瓶颈、优化系统资源分配等；2. 培养学生具备基本的操作系统编程能力，如进程创建、线程同步、文件操作等；3. 提高学生的团队协作能力和沟通能力，通过小组讨论和项目实践，学会共同解决问题。

情感态度价值观目标：1. 培养学生对操作系统学科的兴趣，激发学生的学习热情，使其形成积极向上的学习态度；2. 培养学生具备良好的信息素养，尊重知识产权，遵循法律法规；3. 培养学生的创新精神和批判性思维，敢于质疑、勇于探索，形成独立思考的能力。

课程性质：本课程为计算机科学与技术专业的核心课程，旨在让学生掌握操作系统的基本原理和实现方法，提高学生的系统分析和编程能力。

学生特点：学生具备一定的编程基础和计算机系统知识，具有较强的逻辑思维能力和动手实践能力。

教学要求：结合学生特点和课程性质，注重理论与实践相结合，通过案例分析和项目实践，帮助学生将所学知识内化为具体的学习成果。

在教学过程中，关注学生的学习进度和反馈，及时调整教学策略，确保课程目标的实现。

二、教学内容1. 操作系统概述：介绍操作系统的定义、发展历程、功能、类型及特点，对应教材第一章内容。

- 操作系统的起源与发展- 操作系统的功能与类型- 操作系统的主要特点2. 进程与线程：讲解进程与线程的概念、状态、调度算法，对应教材第二章内容。

- 进程与线程的定义与区别- 进程状态与转换- 进程调度算法3. 内存管理：分析内存管理的基本原理、策略和技术，对应教材第三章内容。

- 内存分配与回收策略- 虚拟内存技术- 页面置换算法4. 文件系统：介绍文件系统的基本概念、结构、存储原理，对应教材第四章内容。

#操作系统课程设计-银行家算法(流程图源代码设计报告)

操作系统课程设计－银行家算法(流程图+源代码+设计报告)一、实验目的：熟悉银行家算法，理解系统产生死锁的原因及避免死锁的方法,加深记意。

二、实验要求：用高级语言编写和调试一个描述银行家算法的程序。

三、实验内容：1、设计一个结构体，用于描述每个进程对资源的要求分配情况。

包括：进程名——name[5]，要求资源数目——command[m]（m类资源），还需要资源数目——need[m]，已分配资源数目——allo[m]。

2、编写三个算法，分别用以完成：①申请资源；②显示资源；③释放资源。

（动态完成）四、程序流程图五、源程序：最新版本：bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改# define NP 10*//* # define NS 5 */ /*资源种类*//*bk3.c::可以继续分配资源（〉2）*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外，对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*//*四、程序流程图：五、源程序：最新版本：bk5.c/*bk2.c::可以自定义进程及资源数目,可选择读文件或创建新文件,但不超过10,5*//*可修改#define NP10*//* #define NS5*//*资源种类*//*bk3.c::可以继续分配资源（〉2）*//*bk4.c::可保存分析结果*//*bk5.c::除以上功能外，对暂时不能分配的可以进行另外一次尝试,并恢复已分配的资源*/ #include "string.h"#include "stdio.h"#include"dos.h"#include"conio.h"#define MOVEIN1#define GUIYUE2#define ACC3#define OK1#define ERROR0#define MAXSH7#define MAXSHL10#define MAXINPUT50#define maxsize 100int act;int ip=0;int line=0; /*line为要写的行号，全局变量*/int writeok;int right;char wel[30]={"Welcome To Use An_Li System"};char ente[76]={" 警告：未经作者同意不得随意复制更改！"};char rights[40]={"Copyright (c)2002"};struct date today;sssssssssssss;ttttttttttttt{int data[maxsize];int top;}stack;int emptystack(stack*S){if(S->top==48&&S->data[S->top]==35)return(1); /*35is'#'*/else return(0);}int push(stack*S,int x){if(S->top>=maxsize-1)return(-1);else{S->top++;S->data[S->top]=x;return(0);}int gettop(stack*S){return S->data[S->top];}int pop(stack*S){if(emptystack(S)){printf("the stack is empty\n");exit(1);}else S->top--;return S->data[S->top+1];}void initstack(stack*S){int i;S->top=0;S->data[S->top]=35;}/*****模拟打字机的效果*********/delay_fun(){int i;void music();for(i=0;;i++){if(wel!='\0'){delay(1000);textcolor(YELLOW);gotoxy(26+i,8);cprintf("%c",wel);printf("谢谢");printf("网络");music(1,60);}else break;}delay(500000);for(i=0;;i++){if(ente!='\0'){delay(1000);textcolor(RED);/*显示警告及版权*/gotoxy(2+i,11);cprintf("%c",ente);}else break;}delay(40000);for(i=0;;i++){if(rights!='\0'){delay(1000);textcolor(YELLOW);gotoxy(30+i,14);cprintf("%c",rights);music(1,60);}elsebreak;}getch();}/*********登陆后的效果**********/ logined(){int i;clrscr();gotoxy(28,10);textcolor(YELLOW);cprintf("程序正在载入请稍候....."); gotoxy(35,12);for(i=0;i<=50;i++){gotoxy(40,12);delay(8000);cprintf("%02d%已完成",i*2);gotoxy(i+15,13);cprintf("\n");cprintf("|");}main0();}/*********对PC扬声器操作的函数****/void music(int loop,int f)/*f为频率*/ {int i;for(i=0;i<30*loop;i++){sound(f*20);}int analys(int s,int a){int hh,pos;switch(a){case(int)'i':hh=0;break;case(int)'+':hh=1;break;case(int)'*':hh=2;break;case(int)'(':hh=3;break;case(int)')':hh=4;break;case(int)'#':hh=5;break;case(int)'E':hh=6;break;case(int)'T':hh=7;break;case(int)'F':hh=8;break;default:{printf("\n analys()分析发现不该有的字符%c!(位置:%d)",a,ip+1); writeerror('0',"\n............分析出现错误!!!");writeerror(a,"\n 错误类型: 不该有字符");printf("谢谢");printf("网");return ERROR;}}pos=(s-48)*10+hh;switch(pos){case3:case43:case63:case73:act=4;return MOVEIN;case0:case40:case60:case70:act=5;return MOVEIN;case11:case81:act=6;return MOVEIN;case92:case22:act=7;return MOVEIN;case84:act=11;return MOVEIN;/*-------------------------------------------*/case91:case94:case95:act=1;return GUIYUE;case21:act=2;return GUIYUE;case101:case102:case104:case105:act=3;return GUIYUE;case31:case32:case34:case35:act=4;return GUIYUE;case111:case112:case114:case115:act=5;return GUIYUE;case51:case52:case54:case55:act=6;return GUIYUE;/*+++++++++++++++++*/case15:return ACC;/*******************************/case6:return1;case7:case47:return2;case8:case48:case68:return3;case46:return8;case67:return9;case78:return10;default:{if(a=='#')printf("");else printf("\n analys() 分析发现字符%c 不是所期望的!(位置:%d)",a,ip+1);writeerror('0',"\n...........分析出现错误!!!");writeerror(a,"\n 错误类型: 字符");writeerror('0'," 不是所期望的!");printf("谢谢");printf("网");return ERROR;}}}int writefile(int a,char*st){FILE*fp;fp=fopen("an_slr.txt","a");{fprintf(fp,"%s",st); /*若a==－1则为添加的注释*/}else if(a==-2){getdate(&today);gettime(&now);fprintf(fp,"\n测试日期：%d-%d-%d",today.da_year,today.da_mon,today.da_day);测试时间：%02d:%02d:%02d",now.ti_hour,now.ti_min,now.ti_sec); fprintf(fp,"}else if(a>=0)fprintf(fp,"\n step:%02d,%s",a,st);writeok=1;fclose(fp);}return writeok;}int writeerror(char a,char*st) /*错误类型文件*/{FILE*fpp;fpp=fopen("an_slr.txt","a");if(fpp==0){printf("\nwrite error!!");writeok=0;}else{if(a=='0')fprintf(fpp,"%s",st); /*若a=='0' 则为添加的注释*/else fprintf(fpp,"%s\'%c\'(位置:%d)",st,a,ip+1);writeok=1;fclose(fpp);}return writeok;}/*^^^^^^^^^^^^^^^^^^^^^^*/main0(){int an,flag=1,action,lenr;char a,w[MAXINPUT];int len,s,ss,aa,ana;stack*st;char r[MAXSH][MAXSHL];/*初始化产生式*/strcpy(r[0],"S->E");strcpy(r[1],"E->E+T");strcpy(r[2],"E->T");strcpy(r[3],"T->T*F");strcpy(r[4],"T->F");strcpy(r[5],"F->(E)");strcpy(r[6],"F->i");clrscr();printf("\nplease input analyse string:\n");gets(w);len=strlen(w);w[len]='#';w[len+1]='\0';push(st,48); /*(int)0 进栈*/writefile(-1,"\n------------------------SLR(1)词法分析器-------------------------"); writefile(-1,"\n计本003 安完成于2003.01.1214:04"); writefile(-1,"\n谢谢");writefile(-1,"网");writefile(-1,"\n 以下为串");writefile(-1,w);writefile(-1,"('#'为系统添加)的分析结果：");writefile(-2,"");do{s=gettop(st);aa=(int)w[ip];action=analys(s,aa);if(action==MOVEIN){ss=48+act;push(st,aa);push(st,ss); /*if ss=4int=52*/ip++;}else if(action==GUIYUE){lenr=strlen(r[act])-3;for(an=0;an<=2*lenr-1;an++)pop(st); /*#0 */s=gettop(st); /*s=0*/push(st,(int)r[act][0]);/*将产生式左端F 进栈*/ana=analys(s,(int)r[act][0])+48;if(ana>59)printf("\分析出错:ana>59!!!");push(st,ana);/*analys(s,aa)即为goto(s',aa)*/if((line+1)%20==0){printf("\nThis screen is full,press any key to continue!!!");getche();clrscr();}printf("step%02d: %s\n",line++,r[act]);writefile(line,r[act]);}else if(action==ACC){flag=0;right=1;}else if(action==ERROR){flag=0;right=0;}/*接受成功*/else{flag=0;right=0;}/* 出错*/}while(flag==1);if(right==1)printf("\nok,输入串%s 为可接受串!!",w);if(right==0)printf("\nsorry,输入串%s 分析出错!!",w);if(writeok==1){printf("\nAnWin soft have wrote a file an_slr.txt");if(right==1)writefile(-1,"\n最终结果：输入串为可接受串!");}}main() /*主函数*/{clrscr();delay_fun();logined();}六、测试报告－操作系统课程设计－银行家算法(流程图+源代码+设计报告)六、测试报告：（测试结果保存于系统生成的an.txt 文件中）以下为课本上的实例：：-------------------------------------------------------------------------------------========================银行家算法测试结果=========================-------------------------------------------------------------------------------------T0 时刻可用资源(Available)A:3,B:3,C:2测试日期：2003-6-28请求分配时间：14:07:29经测试，可为该进程分配资源。

操作系统课程设计项目参考

滴加碘液后
滴加碘液前
12/12/2021
第十二页，共二十三页。
消化(xiāohuà)：在消化道内将食物分解成可吸收 (xīshōu)的成分的过程
（包括物理性消化和化学性消化）
吸收(xīshōu)：营养物质通过消化道壁进入循环系统的过程
12/12/2021
第十三页，共二十三页。
消化(xiāohuà)和吸收的过程
12/12/2021
第十九页，共二十三页。
练习(liànxí)
• 2、分析数据，指出(zhǐ chū)哪一部分消化道中消化液最多。
• 在每天摄入800克食物和1200毫升水的情况下，消化腺大致分泌以下数量消化液。 1500毫升唾液 2000毫升胃液 1500毫升肠液 500毫升胆汁 1500毫升胰液
12/12/2021
第二十二页，共二十三页。
内容总结 (nèiróng)
第二节。食物中的营养物质是在消化系统中被消化和吸收的。这粒西瓜籽在姗姗的消化道内，经过了难忘的时光。它先遇到像轧钢机似的上、下尖硬的怪物，差点儿将它压得粉身碎骨。后来它
No 钻进了一条(yī tiáo)又长又窄的迷宫，它在这里走了很久，身边的许多物质都神秘地消失了。走出迷
唾液腺、胃腺(wèixiàn)、肝脏、胰腺、肠腺
1、淀粉在__口__腔__开始消化、蛋白质在____开始胃消化、脂肪在_______开始消小化肠。
2、胆汁是一种消化液，但不含消化酶，起乳化脂肪的作用。
二、人体消化、吸收的主要器官—— _____小肠能训练解
胰脏：分泌(fēnmì)胰液肠腺：分泌肠液
肝脏：最大的腺体，分泌胆汁。胆汁无消化酶，有乳化脂肪的
作用。
第七页，共二十三页。

算法设计和分析课程论文

湖南理工学院课程论文论文题目贪心法的应用课程名称算法设计与分析姓名学号专业计算机科学与技术年级学院计算机日期（2014年4月10日）课程论文评价标准贪心法的应用摘要：在解决问题的过程中，通过逐步获得最优解从而获得整体最优解的策略就是贪心策略，在已经学会在解的范围可以确定的情况下，可以采用枚举或递归策略，一一比较它们最后找到最优解；但当解的范围非常大时，枚举和递归的效率会非常低。

这时就可以考虑用贪心策略。

贪心算法没有固定的框架，算法设计的关键是贪心策略的选择，贪心策略要具有无后向性，即某阶段状态一旦确定以后，不受这个状态以后的策略的影响。

当一个问题有好几种解决方法时，贪心法应该是最好的选择之一。

本文讲述了贪心算法的含义、基本思路以及贪心算法在实例中的应用。

关键词：贪心算法；删数问题；最小生成树一、引言在平时解决问题的过程中，当一个问题就有无后向性和贪心选择性质时，贪心算法通常会给出一个简单、直观和高效的解法。

贪心算法通过一系列的选择来得到一个问题的解。

它所做的每一个选择都是当前状态下就有某种意义的最好选择，即贪心选择；并且每次贪心选择都能将问题化解为一个更小的与原问题具有相同形式的子问题。

尽管贪心算法对于很多问题不能总是产生整体最优解，但对于最短路径、最小生成树问题，以及删数问题等却可以获得整体最优解，而且所给出的算法一般比动态规划算法更为简单、直观和高效。

二、贪心算法的含义和特点（一）贪心算法的含义贪心算法是通过一系列的选择来得到问题解的过程。

贪心算法是一种能够得到某种度量意义下的最优解的分级处理方法，它总是做出在当前看来是最有的选择，也就是说贪心策略并不是从整体上加以考虑，它所做出的选择只是在某种意义上的局部最优解算法。

（二）贪心算法的特点1、从全局来看，运用贪心策略解决的问题在程序运行过程中无回溯过程，后面的每一步都是当前看似最佳的选择，这种选择依赖已作出的选择，但并不依赖未作出的选择。

2、不能保证最后求出的解是最佳的。

西电操作系统课程设计

西电操作系统课程设计《西电操作系统课程设计》——学习与实践的完美结合在西安电子科技大学的操作系统课程设计中，学生们能够通过一系列的学习和实践活动，全面了解和掌握操作系统的基本原理、设计方法和实际应用。

这个课程设计旨在培养学生的实践能力，提高他们对操作系统的理解和应用能力。

学生们在课程设计中将分为几个阶段进行学习和实践。

首先，他们将通过理论课程学习操作系统的基本概念、组成结构和工作原理。

在此基础上，他们还将学习操作系统的设计和实现方法，了解各种算法和数据结构在操作系统中的应用。

这些理论知识将为后面的实践活动打下基础。

其次，学生们将参与到项目实践中，通过团队合作完成一个实际的操作系统项目。

这个项目将要求学生们设计和实现一个简化版的操作系统，并加入一些基本的功能和特性。

在这个过程中，学生们将运用他们所学的理论知识，使用编程语言和工具进行系统开发和调试。

通过这种实践活动，学生们将锻炼他们的编码能力、问题解决能力和团队合作精神。

最后，学生们还将进行操作系统实验，通过模拟实际的操作系统场景，了解和掌握操作系统的功能和性能。

他们将在实验中使用各种工具和技术，观察和分析操作系统的行为和性能，并提出改进措施。

通过这些实验，学生们将深入了解操作系统的各个方面，并培养他们的实际操作和问题解决能力。

在《西电操作系统课程设计》中，学生们通过学习和实践，全面掌握操作系统的理论知识，提高他们的实际应用能力。

这种学习方式结合了理论与实践，使学生们能够真正地理解和应用操作系统的概念和方法。

同时，通过参与项目实践和操作系统实验，学生们还能够提高他们的编码能力、问题解决能力和团队合作精神。

这样的课程设计不仅扩展了学生们的知识面，还培养了他们的实践能力和创新能力，使他们能够更好地应对未来的挑战。

操作系统课程设计----模拟银行家算法避免死锁

模拟通过银行家算法避免死锁一、银行家算法产生的背景及目的1：在多道程序系统中，虽然借助于多个进程的并发执行来改善系统的利用率，提高系统的吞吐量，但可能发生一种危险—死锁。

死锁就是多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵局状态时，如无外力作用，他们将无法再向前进行，如再把信号量作为同步工具时，多个Wait 和Signal操作顺序不当，会产生进程死锁。

然而产生死锁的必要条件有互斥条件，请求和保持条件，不剥夺条件和环路等待条件。

在预防死锁的几种方法中，都施加了较强的限制条件，在避免死锁的方法中，所施加的条件较弱，有可能获得令人满意的系统性能。

在该方法中把系统的状态分为安全状态和不安全状态，只要能使系统都处于安全状态，便可避免死锁。

2：实验目的：让学生独立的使用编程语言编写和调试一个系统分配资源的简单模拟程序，了解死锁产生的原因及条件。

采用银行家算法及时避免死锁的产生，进一步理解课堂上老师讲的相关知识点。

银行家算法是从当前状态出发，逐个按安全序列检查各客户中谁能完成其工作，然后假定其完成工作且归还全部贷款，再进而检查下一个能完成工作的客户。

如果所有客户都能完成工作，则找到一个安全序列，银行家才是安全的。

二：银行家算法中的数据结构1：可利用资源向量Available。

这是一个含有m个元素的数组，其中的每个元素代表一类可利用的资源数目，其初始值是系统中所配置的该类全部可用资源的数目，其数值随该类资源的分配和回收而动态的改变。

如果Available[j]=k，z则表示系统中现有Rj类资源K 个。

2：最大需求矩阵Max。

这是一个n*m的矩阵，它定义了系统中n个进程中的每一个进程对m类资源的最大需求。

如果Max[i,j]=k，表示第i个进程需要第Rj类资源的最大数目k个.3: 分配矩阵Allocation,也是n*m的矩阵，若Allocation[i,j]=k,表示第i个进程已分配Rj类资源的数目为k个。

谈计算机操作系统课程知识体系设计

・郭风，南京师范大学计算机科学与技术学院・杨玺，南京师范大学计算机科学与技术学院
・
教学实录
度算法各知识点；法评价包含作业调度算法评价、程点。算进（）享技术知识模块是提高资源利用率的必然途２共径，括处理机共享、储共享、备共享、件共享它包存设文（存储器管理知识模块包括存储管理功能、储管３）存存理方案各知识单元。存储管理功能包含内存分配与回收、各知识单元。处理机共享包含进程的并发执行；储共享
业的一门重要专业基础理论课，既使这门课程的教学学思想、理机制，线主要指功能实现的具体技术方法、这处横
习存在非常大的困难和困惑，使其无论在教学、学研不同环境下的实现差异。又科因此，个课程知识体系可按纵、整究和项目开发中都处于非常重要的地位。
教学实录・
谈计算机操作系统课程知识体系设计
郭风水杨玺水木
【内容摘要】操作系统课程理论性强且内容繁杂，文设计了于资源管理功能和技术实现纵横两条本基线设计的课程知识体系，呈现给学生比较清晰的知识结构，养学生从离散到系统性的学习和思维习惯为培
算机专业软、硬件课程的设置上起着承上启下的作用，其互斥包含与时间有关的错误、临界资源与临界区、界区临中的许多设计思想、技术和算法都可以推广和应用到大型使用原则、临界区互斥访问的解决途径、界区互斥访问临的、杂的系统设计，复以及其他领域。因此，教学目标应的解决途径各知识点；程同步包含信号量同步机制、其进生重在培养学生理解和掌握计算机操作系统的基本工作原产者与消费者问题、者与写者问题、学家进餐问题各读哲理、计技术及设计方法，养学生开发系统软件和大型知识点；程通信包含忙等待策略、设培进睡眠和唤醒策略、消息应用软件的意识和能力，还要让学生了解现代操作系传递策略各知识点；同时进程死锁包含产生原因、要条件、必解

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

课程设计报告题目操作系统算法设计课程名称操作系统课程设计院部名称计算机工程学院专业计算机科学与技术班级 14计算机科学与技术单学生姓名邵佳楠学号 141320100课程设计地点 A107课程设计学时 20学时指导教师潘金陵科技学院教务处制成绩目录摘要 (2)一、课程设计的目的和要求 (3)二、系统需求分析 (3)三、总体设计 (3)四、详细设计 (4)五、测试、调试过程 (7)六、结论与体会 (16)附录：源程序 (17)摘要 (32)一、课程设计的目的和要求 (33)二、系统需求分析 (33)三、总体设计 (33)四、详细设计 (33)五、测试、调试过程 (34)六、结论与体会 (38)附录：源程序 (39)摘要 (47)一、设计的目的和要求 (47)二、系统需求分析 (48)三、总体设计 (48)四、详细设计 (48)五、测试、调试过程 (50)六、结论与体会 (54)附录：源程序 (55)操作系统算法设计-进程调度程序摘要随着计算机的普及，人们生活得到极大改善，人们在精神方面也同样需要提高，所以越来越多的人进行着各种各样的学习。

操作系统是计算机中最重要的环节之一，也是计算机专业学生的一门重要的专业课程。

操作系统的好坏，直接影响整个计算机系统的性能和用户对计算机的使用。

一个精心设计的操作系统能极大的扩展计算机的功能，充分发挥系统中的各种设备的使用效率，提高系统的可靠性。

由于操作系统中各种软硬件资源的管理，内容比较繁琐，具有很强的实践性，要学好这门课程，必须把理论和时间紧密结合，才能取得较好的学习效果。

本次课程设计师在学习完《操作系统教程》后，进行的一次全面的综合训练，通过课程设计，让学生更好的掌握操作系统的原理以及实现方法，加深对操作系统基础理论和重要算法的理解，加强对学生的动手能力。

熟悉“最高优先级优先调度算法”、“基于时间片轮转法”、“多级反馈队列调度算法”、“最高优先级优先算法”，虽然不用全部每一个都弄清楚，但是了解其中的算法思想也是有好处的。

关键词：最高优先级优先调度算法、基于时间片轮转法、多级反馈队列调度算法、最高优先级优先算法一、课程设计的目的和要求程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。

二、系统需求分析在多道程序系统中，一个作业被提交后必须经过处理机调度后，方能获得处理机执行。

对于批量型作业而言，通常需要经历作业调度（又称高级调度或长程调度）和进程调度（又称低级调度或短程调度）两个过程后方能获得处理机；对于终端型作业，则通常只需经过进程调度即可获得处理机。

在较完善的操作系统中，为提高内存的利用率，往往还设置了中级调度（又称中程调度）。

对于上述的每一级调度，又都可采用不同的调度方式和调度算法。

三、总体设计编写进程调度程序，“最高优先级优先”算法常用语批处理系统中，在进程调度中，每次调度时，系统把处理机给就绪队列中优先级最高的进程。

在非抢占式优先级算法下系统一旦把处理机分配给就绪队列中优先级最高的进程后，这个进程就会一直运行，直到完成或发生某事件使它放弃处理机，这时系统才能重新将处理机分配给就绪队列中的理你个优先级最高的进程。

静态优先级是在创建进程时确定的，并在整个运行期间不再改变。

动态优先级是指进程的优先级在创建进程时可以给定一个初始值，并且可以按一定原则修改优先级。

“轮转法”算法中，系统将所有的就绪进程按先来先服务的原则，排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

时间片的大小从几ms到几百ms。

当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾;然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程，在一给定的时间内，均能获得一时间片的处理机执行时间。

“多级反馈队列调度”算法中，进程在进入待调度的队列等待时，首先进入优先级最高的队列等待。

先调度优先级高的队列中的进程，若高优先级中队列中已没有调度的进程，则调度次优先级队列中的进程。

对于同一个队列中的各个进程，按照时间片轮转法调度。

在低优先级的队列中的进程在运行时，又有新到达的作业，那么在运行完这个时间片后，CPU马上分配给新到达的作业（抢占式）。

最高优先级优先算法:从键盘输入若干个进程，进程包括进程名，进程优先级，进程运行时间。

就绪队列按照优先级从高到低排列，进程调度中，获取就绪队列队首进程，即优先级最高的进程，在进程获得一次CPU后，就将该进程的优先级减1。

重新排列就绪队列，获取就绪队列队首进程进行调度。

四、详细设计进程调度程序中，静态优先级算法的基本原理与简单轮转调度的算法还有多级反馈调度算法相似，都是先用户输入进程信息、对用户输入的进程按优先级排序，然后输出就绪队列中的进程、输出正在运行的进程、输出已完成的进程、静态优先级算法，区别在于简单轮转调度算法多一个对用户输入的进程按FCFS排序。

动态优先级算法是根据静态优先级算法进行更改，总体差不多只是相对灵活性更加灵活。

而多级反馈调度算法是按优先级排序，整体上差不多。

下面是各个算法的程序流程图：初始化是否开始输入进程按优先级高低排入就绪队列中是否继续输入进程就绪队列是否为空获取就绪队列队首进程进程获得一个CPU该进程是否完成按优先级高低插入就绪队列中释放进程节点结束NYYNNYYN图1.1 最高优先级优先算法流程图初始化是否开始输入进程按先来先服务排入就绪队列中是否继续输入进程就绪队列是否为空获取就绪队列队首进程进程在时间片T内运行该进程是否完成排入就绪队列队尾释放进程节点结束NYYNNYYN图1.2 简单轮转法优先算法流程图图1.3 多级反馈调度算法流程图五、测试、调试过程在静态优先级调度算法中，判断出了在运用getch()的时候需要头文件#include <conio.h>这一项的。

动态优先级算法在根据静态优先级算法的基础上改的整体的框架没有改变，简单轮转调度算法、多级反馈调度算法和静态优先级初始化退出系统选择功能菜单输入进程是否继续输入按先来先服务算法插入就绪第一队列是否完成获取最高优先队列队首进程，若为空，则，寻在下一队列该进程获取CPU 的一个时间片时间释放进程节点把该进程插入所在队列（n ）的下一个队列（n+1）的队尾是否找到进程调度算法都有一个通用的问题就是conio.h，在编写程序的过程中要熟悉系统文件的头文件对应的功能。

下面是各个程序的运行结果：静态优先级调度算法：动态优先级调度算法：简单轮转调度算法：多级反馈调度算法：六、结论与体会在运行的这几个程序中，普遍的问题就是缺少头文件，或者是系统的函数在没有弄清楚的情况下没有注意分开。

操作系统这门课与实际运用联系也是很大的，比如银行家算法，虽然课程设计里面没有做到。

在程序的几个调度算法中其实也可以看到现实的例子，比如进程调度，我们可以把他设计成一个公司内部管理调度，其性质和原理其实是一样的并没有什么太大的区别。

在这门课上我学习到了如何独立自主的面对程序调试运行出现的问题。

冷静的思考是很有必要的。

附录：源程序进程调度程序//静态优先级调度算法.c#include <stdio.h>#include <conio.h>#include <string.h>#define MAX 24struct pcb//建立进程控制块{char pname[10];int priority;int reachtime;int needtime;int usecputime;char status;};typedef struct pcb PCB;void inputpcb(PCB pcb[],int *n)//用户输入进程信息{int i;int num;printf("\n请输入进程个数");scanf("%d",&num);for(i=0;i<num;i++){printf("\n请输入第%d个进程的名称:",i+1);scanf("%s",pcb[i].pname);printf("\n请输入第%d个进程的优先级:",i+1);scanf("%d",&pcb[i].priority);printf("\n进程的默认到达时间为O.\n");printf("\n请输入第%d个进程的运行时间:",i+1);scanf("%d",&pcb[i].needtime);pcb[i].reachtime=0;pcb[i].usecputime=0;pcb[i].status='r';*n=num;}void paixupcb(PCB pcb[],int n)//对用户输入的进程按优先级排序{int i,j;PCB pcbtemp;for(i=0;i<n-1;i++){for(j=i+1;j<n;j++){if(pcb[i].priority<pcb[j].priority){pcbtemp=pcb[i];pcb[i]=pcb[j];pcb[j]=pcbtemp;}}}}void printpcb(PCB pcb[],int n)//输出就绪队列中的进程{int i;printf("\n进程名优先级到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status!='F')printf("\n %s %d %d %d %d %c",pcb[i].pn ame,pcb[i].priority,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void printRpcb(PCB pcb[],int n)//输出正在运行的进程{printf("\n进程名优先级到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status=='R')printf("\n %s %d %d %d %d %c",pcb[i].pn ame,pcb[i].priority,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void printFpcb(PCB pcb[],int n)//输出已完成的进程{int i;printf("\n进程名优先级到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status=='F')printf("\n %s %d %d %d %d %c",pcb[i].pn ame,pcb[i].priority,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void staPRI(PCB pcb[],int n,int times)//静态优先级算法{int i=0;printf("\n当前的系统时间为:%d\n",times);getch();printf("\n按优先级排序，到达就绪队列中的进程为：");paixupcb(pcb,n);getch();for(i=0;i<n;i++){while(pcb[i].needtime>pcb[i].usecputime){pcb[i].status='R';printf("\n按静态优先级对进程调度，正在运行的进程为：");pcb[i].usecputime++;times++;printRpcb(pcb,n);getch();printf("\n当前的系统时间为:%d\n",times);getch();pcb[i].status='r';paixupcb(pcb,n);if(pcb[i].needtime==pcb[i].usecputime){pcb[i].status='F';printf("\n此时刻，进程%s已经完成，进程%s被撤销!\n",pcb[i].pname,pcb[i].pname);getch();}printf("\n按优先级排序，就绪队列中的进程为：");printpcb(pcb,n);getch();}}printf("\n按优先级队列中已经没有进程，至此，所有的进程已经完成!\n");getch();printf("\n完成信息如下：");printFpcb(pcb,n);getch();printf("\n\n进程调度完毕!请按任意键退出!");}//动态优先级算法void dynPRI(PCB pcb[],int n,int times){int i=0;char temp[10];int min; ;printf("\n当前的系统时间为:%d\n",times);getch();printf("\n按优先级排序，到达就绪队列中的进程为："); paixupcb(pcb,n);printpcb(pcb,n);getch();for(i=0;i<n-1;i++){if(pcb[i].reachtime>pcb[i+1].reachtime){min=pcb[i].reachtime;pcb[i].reachtime=pcb[i+1].reachtime;pcb[i+1].reachtime=min;min=pcb[i].needtime;pcb[i].needtime=pcb[i+1].needtime;pcb[i+1].needtime=min;min=pcb[i].priority;pcb[i].priority=pcb[i+1].priority;pcb[i+1].priority=min;strcpy(temp,pcb[i].pname);strcpy(pcb[i].pname,pcb[i+1].pname);strcpy(pcb[i+1].pname,temp);}}for(i=0;i<n;i++){if(pcb[i].priority<pcb[i+1].priority){min=pcb[i].priority;pcb[i].priority=pcb[i+1].priority;pcb[i+1].priority=min;min=pcb[i].reachtime;pcb[i].reachtime=pcb[i+1].reachtime;pcb[i+1].reachtime=min;min=pcb[i].needtime;pcb[i].needtime=pcb[i+1].needtime;pcb[i+1].needtime=min;strcpy(temp,pcb[i].pname);strcpy(pcb[i].pname,pcb[i+1].pname);strcpy(pcb[i+1].pname,temp);// pcbs[i].usetime++;} //按进程优先级排序，最高的排在最前面}printf("\n按优先级队列中已经没有进程，至此，所有的进程已经完成!\n");getch();printf("\n完成信息如下：");printFpcb(pcb,n);getch();printf("\n\n进程调度完毕!请按任意键退出!");}void main(){PCB pcbr[MAX];int pnum=0;int systime=0;printf("\t\t\t\t进程调度模拟演示程序");inputpcb(pcbr,&pnum);printf("\n用户输入的进程信息为：");printpcb(pcbr,pnum);staPRI(pcbr,pnum,systime);}//简单轮转法调度算法.c#include <stdio.h>#include <string.h>#include <conio.h>#define MAX 24struct pcb//建立进程控制块{char pname[10];int reachtime;int needtime;int usecputime;char status;};typedef struct pcb PCB;void inputpcb (PCB pcb[],int *n)//用户输入进程信息{int i;int num;printf("\n请输入进程个数");scanf("%d",&num);for(i=0;i<num;i++){printf("\n请输入第%d个进程的名称:",i+1);scanf("%s",&pcb[i].pname);printf("\n请输入第%d个进程的提交时间:",i+1);scanf("%d",&pcb[i].reachtime);printf("\n请输入第%d个进程的运行时间:",i+1);scanf("%d",&pcb[i].needtime);pcb[i].usecputime=0;pcb[i].status='r';}*n=num;}void fcfspcb(PCB pcb[],int n)//对用户输入的进程按FCFS排序{int i,j;PCB pcbtemp;for(i=0;i<n-1;i++){for(j=i+1;j<n;j++){if(pcb[i].reachtime>pcb[j].reachtime){pcbtemp=pcb[i];pcb[i]=pcb[j];pcb[j]=pcbtemp;}}}}void printpcb(PCB pcb[],int n)//输出用户输入的进程{int i;printf("\n进程名到达时间需要运行时间");for(i=0;i<n;i++){printf("\n %s %d %d",pcb[i].pname,pcb[i].reachtime,pcb[ i].needtime);}printf("\n");}void printrpcb(PCB pcb[],int n)//输出就绪队列中的进程{int i;printf("\n进程名到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status=='r')printf("\n %s %d %d %d %c",pcb[i].pname,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void printRpcb(PCB pcb[],int n)//输出正在运行的进程{int i;printf("\n进程名到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status=='R')printf("\n %s %d %d %d %c",pcb[i].pname,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void printFpcb(PCB pcb[],int n)//输出已完成的进程{int i;printf("\n进程名到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status=='F')printf("\n %s %d %d %d %c",pcb[i].pname,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void simTSC(PCB pcb[],int n){int i=0;int j;PCB pcbtemp;printf("\n按先来先服务排序，就绪队列中的进程:");fcfspcb(pcb,n);getch();while(pcb[i].needtime>pcb[i].usecputime&&i<n){pcb[i].status='R';printf("\n按简单时间片轮转发对进程进行调度，正在运行的进程为:");pcb[i].needtime++;printRpcb(pcb,n);getch();if(pcb[i].needtime==pcb[i].usecputime){pcb[i].status='F';printf("\n此时刻，进程%s已经完成，进程%s被撤销!\n",pcb[i].pname,pcb[i].pname);getch();i++;}else{pcb[i].status='r';pcbtemp=pcb[i];for(j=i;j<n-1;j++){pcb[j]=pcb[j+1];}pcb[j]=pcbtemp;}printf("\n本次调度完成!准备进行下一次调度.\n");getch();printf("\n就绪队列中的进程为:");printrpcb(pcb,n);getch();}printf("\n就绪队列中已经没有进程，致辞，所有的进程已经完成");getch();printf("\n完成信息如下:");printFpcb(pcb,n);getch();printf("\n\n进程调度完毕!请按任意键退出!"); }void main(){PCB pcbr[MAX];int pnum=0;printf("\t\t\t\t进程调度模拟演示程序");inputpcb(pcbr,&pnum);printf("\n用户输入的原始程序信息为:");printpcb(pcbr,pnum);simTSC(pcbr,pnum);}//多级反馈队列调度算法.c#include <stdio.h>#include <conio.h>#include <string.h>#define MAX 24struct pcb//建立进程控制块{char pname[10];int priority;int reachtime;int needtime;int usecputime;char status;};typedef struct pcb PCB;void inputpcb(PCB pcb[],int *n)//用户输入进程信息{int i;int num;printf("\n请输入进程个数");scanf("%d",&num);for(i=0;i<num;i++){printf("\n请输入第%d个进程的名称:",i+1);scanf("%s",pcb[i].pname);printf("\n请输入第%d个进程的优先级:",i+1);scanf("%d",&pcb[i].priority);printf("\n进程的默认到达时间为O.\n");printf("\n请输入第%d个进程的运行时间:",i+1);scanf("%d",&pcb[i].needtime);pcb[i].reachtime=0;pcb[i].usecputime=0;pcb[i].status='r';}*n=num;}void paixupcb(PCB pcb[],int n)//对用户输入的进程按优先级排序{int i,j;PCB pcbtemp;for(i=0;i<n-1;i++){for(j=i+1;j<n;j++){if(pcb[i].priority<pcb[j].priority){pcbtemp=pcb[i];pcb[i]=pcb[j];pcb[j]=pcbtemp;}}}}void printpcb(PCB pcb[],int n)//输出就绪队列中的进程{int i;printf("\n进程名优先级到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status!='F')printf("\n %s %d %d %d %d %c",pcb[i ].pname,pcb[i].priority,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void printRpcb(PCB pcb[],int n)//输出正在运行的进程{int i;printf("\n进程名优先级到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status=='R')printf("\n %s %d %d %d %d %c",pcb[i ].pname,pcb[i].priority,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void printFpcb(PCB pcb[],int n)//输出已完成的进程{int i;printf("\n进程名优先级到达时间需要运行时间已用CPU时间进程状态");for(i=0;i<n;i++){if(pcb[i].status=='F')printf("\n %s %d %d %d %d %c",pcb[i ].pname,pcb[i].priority,pcb[i].reachtime,pcb[i].needtime,pcb[i].usecputime,pcb[i].status);}printf("\n");}void staPRI(PCB pcb[],int n,int times)//静态优先级算法{int i=0;printf("\n当前的系统时间为:%d\n",times);getch();printf("\n按优先级排序，到达就绪队列中的进程为：");paixupcb(pcb,n);getch();for(i=0;i<n;i++){while(pcb[i].needtime>pcb[i].usecputime){pcb[i].status='R';printf("\n按静态优先级对进程调度，正在运行的进程为：");pcb[i].usecputime++;times++;printRpcb(pcb,n);getch();printf("\n当前的系统时间为:%d\n",times);getch();pcb[i].status='r';paixupcb(pcb,n);if(pcb[i].needtime==pcb[i].usecputime){pcb[i].status='F';printf("\n此时刻，进程%s已经完成，进程%s被撤销!\n",pcb[i].pname,pcb[i].pname);getch();}printf("\n按优先级排序，就绪队列中的进程为：");printpcb(pcb,n);getch();}}printf("\n就绪队列中已经没有进程，至此，所有的进程已经完成!\n");getch();printf("\n完成信息如下：");printFpcb(pcb,n);getch();printf("\n\n进程调度完毕!请按任意键退出!");}void main(){PCB pcbr[MAX];int pnum=0;int systime=0;printf("\t\t\t\t进程调度模拟演示程序");inputpcb(pcbr,&pnum);printf("\n用户输入的进程信息为：");printpcb(pcbr,pnum);staPRI(pcbr,pnum,systime);}操作系统算法设计-主存分配回收摘要在内存初始化完成以后，内存中就常驻有内核映像（内核代码和数据）。