计算机软件及应用操作系统课设进程调度算法银行家算法.docx
《计算机软件及应用操作系统课设进程调度算法银行家算法.docx》由会员分享，可在线阅读，更多相关《计算机软件及应用操作系统课设进程调度算法银行家算法.docx（45页珍藏版）》请在冰豆网上搜索。
计算机软件及应用操作系统课设进程调度算法银行家算法
北华航天工业学院
《操作系统》
课程设计报告
课设报告题目：
作者所在系部：
计算机科学与工程
作者所在专业：
计算机科学与技术
作者所在班级：
作者姓名：
指导教师姓名：
完成时间：
2011-12-13
北华航天工业学院教务处制
摘要
通过一学期的对操作系统的学习，对操作系统有了一定的知识储备，为了巩固知识，加深印象，也为了更加深入的了解与钻研操作系统，为以后的学习研究提供帮助，做操作系统课设，分别为进程调度算法、银行家算法。
通过进程调度算法课设，解决了进程调度的几个基本算法：
先来先服务算法、短进程优先算法、高响应比算法。
通过银行家算法课设，更加深刻的理解了银行家算法，安全算法避免死锁的原理。
两个课设为两个知识点，都为操作系统的难点与重点，在硬件不允许的情况下通过运用vc++6.0和c++语言描述了它们的功能与具体实现，对以后的学习有很大的帮助。
关键词：
操作系统进程进程调度算法先来先服务短进程优先高响应比
银行家算法安全算法死锁安全序列安全状态
第一章绪论
随着计算机的不断的更新换代，操作系统也越来越多样化，复杂化，这就要求我们大学生掌握一些操作系统的基本知识，了解操作系统的基本原理，能够正确地使用操作系统，直到操作系统的作用，为此，我们列举了两个操作系统中常用的两个知识点，进程调度算法和银行家算法，帮助学生能够较快的了解并掌握这两个常用的知识点。
1.1课程设计的背景和意义
1.1.1课程设计的理论研究基础
1.先来先服务算法：
每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列，每次调度从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
短进程优先调度算法：
从就绪队列中选出一个运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成。
高响应比调度算法：
为每个作业引入动态优先权，并使作业的优先级随着等待时间的增加提高，则长作业等待一定的时间后，必然有机会分配到处理机。
2.银行家算法：
要预防死锁，有摒弃“请求和保持”条件，摒弃“不剥夺”条件，摒弃“环路等待”条件等方法。
而最具代表性的避免死锁的算法，便是Dijkstra的银行家算法。
利用银行家算法，我们可以来检测CPU为进程分配资源的情况，决定CPU是否响应某进程的的请求并为其分配资源，从而很好避免了死锁的产生
1.1.2课程设计的意义
课程设计是学生学习完《操作系统》课程后，进行的一次全面的综合训练，通过课程设计，让学生更好地掌握操作系统的原理及实现方法，加深对操作系统基础理论和重要算法的理解，加强学生的动手能力。
1.2课程设计环境
软件环境：
VC++6.0。
硬件环境：
图书馆5楼实验室
第二章需求分析
2.1功能要求
2.1.1进程调度算法
编程实现进程调度算法的基本过程，设计要求：
（1）能够选择进程调度算法（先来先服务、短进程优先算法和高响应比优先算法）。
（2）可以输入进程数目（至少4个进程），以及各进程的提交时间和运行时间。
（3）能够以下图形式显示调度过程及平均周转时间和平均带权周转时间。
2.1.2银行家算法
编写一程序，能够模拟银行家算法和安全算法来避免死锁。
假设系统资源有A、B、C三种，可以运行5个进程。
该程序具备的基本功能为：
（1）程序可以输入3种资源的数目，5个进程对3种资源的最大需求量、已分配量和需求量。
（2）能够判断某一时刻系统是否处于安全状态，如果处于安全状态能够给出安全序列。
（3）当某进程提出资源申请时，能够判断是否能把资源分配给申请进程。
2.2问题的解决方案
2.2.1进程调度算法
运用先来先服务，短进程优先算法，高响应比算法来实现对操作系统进程的调度算法。
其中运用数据结构中的排序知识便可轻易解决。
2.2.2银行家算法
银行家算法，安全算法查看安全序列，运用数组，循环判断是否存在安全序列，从而即可判断安全性，避免死锁。
第三章系统设计
3.1数据设计
3.1.1结构体设计
1.进程调度算法的结构体设计
（1）structPCB
{
intid;//进程id
floatptime;//到达时间
floatstarttime;//开始时间
floatwaittime;//等待时间
floatfinishtime;//完成时间
floatruntime;//运行时间
floatturntime;//周转时间
floatqtime;//带权周转时间
};//进程控制块
（2）typedefPCBElemType;
typedefstruct
{
ElemTypeelem[100];
intlength;
}SqList;//顺序表，用于存储进程控制块
3.1.2结构体之间的关系
1.进程调度算法
SqList顺序表结构体，用于存储PCB进程控制块，以实现各种方法的进程调度
3.1.3函数设计
1.进程调度算法的函数设计
（1）intListInsert_Sq（SqList&L,inti,ElemTypee）//在顺序表第i个位置插入数据e
（2）voidbubble_sort（ElemTypee[],intn）//冒泡法排序
（3）intListInsert_Sq2（SqList&L,inti,ElemTypee[],intn）//按短进程优先法往顺序表中插入数组e[n]
（4）intListInsert_Sq3（SqList&L,inti,ElemTypee[],intn）//按高响应比法往顺序表中插入数组e[n]
（5）voidFCFS（ElemTypee[],intn）//先来先服务计算各个时间
（6）voidSJF（SqList&L）//短进程优先法计算各个时间
（7）voidFPF（SqList&L）//高响应比法计算各个时间
（8）voidDisplay（SqList&L）//输出函数，把顺序表中的数据输出
2.银行家算法的函数设计
（1）voidinput（intavailable[3],intmax[5][3],intallocation[5][3],intneed[5][3],intfinish[5],stringname[5]）//输入可利用资源数目，最大需求数目，以分配数目，需求数目，完成标记，进程名字
（2）intfenpei（intavailable[3],intallocation[5][3],intneed[5][3],intfinish[5],intxb[5]）//分配函数，检查分配是否安全
（3）intrequest（intavailable[3],intmax[5][3],intallocation[5][3],intneed[5][3],stringname[5]）//请求函数，输入进程名字和资源申请数目
（4）intfanhui（intavailable[3],intmax[5][3],intallocation[5][3],intneed[5][3],stringname[5],string&name2）//申请资源不安全时返还申请资源
第四章系统实现
4.1结构体实现
1.进程调度算法的结构体实现
（1）structPCB
{
intid;//进程id
floatptime;//到达时间
floatstarttime;//开始时间
floatwaittime;//等待时间
floatfinishtime;//完成时间
floatruntime;//运行时间
floatturntime;//周转时间
floatqtime;//带权周转时间
};//进程控制块
（2）typedefPCBElemType;
typedefstruct
{
ElemTypeelem[100];
intlength;
}SqList;//顺序表，用于存储进程控制块
4.2函数实现
4.2.1进程调度算法的函数实现
（1）intListInsert_Sq（SqList&L,inti,ElemTypee）//在顺序表第i个位置插入数据e
{
if（i<1||i>L.length+1）
return0;
if（L.length>=100）
return-1;
intj;
for（j=L.length;j>=i-1;j--）
L.elem[j+1]=L.elem[j];
L.elem[i-1]=e;
L.length++;
return1;
}
（2）voidbubble_sort（ElemTypee[],intn）//冒泡法排序
{
ElemTypet;
inti,j,swap;
for（i=1;i<=n;i++）
{
swap=0;
for（j=0;jif（e[j].ptime>e[j+1].ptime）
{
t=e[j];
e[j]=e[j+1];
e[j+1]=t;
swap=1;
}
if（swap==0）
break;
}
}
（3）intListInsert_Sq2（SqList&L,inti,ElemTypee[],intn）//按短进程优先法往顺序表中插入数组e[n]
{
intj,q,swap,p;
j=0;
q=0;
floatt;
ListInsert_Sq（L,i,e[j]）;
t=e[j].ptime+e[j].runtime;
i++;
j++;
p=j;
for（j;j{
swap=0;
if（e[j].ptime>t）
{
ListInsert_Sq（L,i,e[j]）;
t=e[j].ptime+e[j].runtime;
i++;
p++;
}
elseif（e[j].ptime<=t）
{
q=j;
if（e[j+1].ptime>t||（j+1）>=n）
swap=1;
}
if（swap==1）
{
if（p==q）
{
ListInsert_Sq（L,i,e[q]）;
t=e[q].ptime+e[q].runtime;
i++;
p++;
}
if（q>p）
{
swap=0;
ElemTypex;
for（q;q>p;q--）
if（e[q].runtime{
x=e[q];
e[q]=e[q-1];
e[q-1]=x;
}
}
if（swap==0）
{
ListInsert_Sq（L,i,e[p]）;
t=t+e[p].runtime;
i++;
p++;
j=p-1;
}
}
}
return1;
}
（4）intListInsert_Sq3（SqList&L,inti,ElemTypee[],intn）//按高响应比法往顺序表中插入数组e[n]
{
intj,q,swap,p;
j=0;
q=0;
floatt;
ListInsert_Sq（L,i,e[j]）;
t=e[j].ptime+e[j].runtime;
i++;
j++;
p=j;
for（j;j{
swap=0;
if（e[j].ptime>t）
{
ListInsert_Sq（L,i,e[j]）;
t=e[j].ptime+e[j].runtime;
i++;
p++;
}
elseif（e[j].ptime<=t）
{
q=j;
if（e[j+1].runtime>t||（j+1）>=n）
swap=1;
}
if（swap==1）
{
if（p==q）
{
ListInsert_Sq（L,i,e[q]）;
t=e[q].ptime+e[q].runtime;
i++;
p++;
}
if（q>p）
{
swap=0;
ElemTypex;
for（q;q>p;q--）
if（（t-e[q].ptime）/e[q].runtime>（t-e[q-1].ptime）/e[q-1].runtime）
{
x=e[q];
e[q]=e[q-1];
e[q-1]=x;
}
}
if（swap==0）
{
ListInsert_Sq（L,i,e[p]）;
t=t+e[p].runtime;
i++;
p++;
j=p-1;
}
}
}
return1;
}
（5）voidFCFS（ElemTypee[],intn）//先来先服务计算各个时间
{
inti=0;
while（i{
if（i==0）
{
e[i].starttime=e[i].ptime;
e[i].finishtime=e[i].starttime+e[i].runtime;
e[i].turntime=e[i].finishtime-e[i].ptime;
e[i].qtime=e[i].turntime/e[i].runtime;
}
else
if（e[i].ptime>=e[i-1].finishtime）
{
e[i].starttime=e[i].ptime;
e[i].finishtime=e[i].starttime+e[i].runtime;
e[i].turntime=e[i].finishtime-e[i].ptime;
e[i].qtime=e[i].turntime/e[i].runtime;
}
else
{
e[i].starttime=e[i-1].finishtime;
e[i].waittime=e[i].starttime-e[i].ptime;
e[i].finishtime=e[i].starttime+e[i].runtime;
e[i].turntime=e[i].finishtime-e[i].ptime;
e[i].qtime=e[i].turntime/e[i].runtime;
}
i++;
}
}
（6）voidSJF（SqList&L）//短进程优先法计算各个时间
{
inti=0;
while（i{
if（i==0）
{
L.elem[i].starttime=L.elem[i].ptime;
L.elem[i].finishtime=L.elem[i].starttime+L.elem[i].runtime;
L.elem[i].turntime=L.elem[i].finishtime-L.elem[i].ptime;
L.elem[i].qtime=L.elem[i].turntime/L.elem[i].runtime;
}
else
if（L.elem[i].ptime>=L.elem[i-1].finishtime）
{
L.elem[i].starttime=L.elem[i].ptime;
L.elem[i].finishtime=L.elem[i].starttime+L.elem[i].runtime;
L.elem[i].turntime=L.elem[i].finishtime-L.elem[i].ptime;
L.elem[i].qtime=L.elem[i].turntime/L.elem[i].runtime;
}
else
{
L.elem[i].starttime=L.elem[i-1].finishtime;
L.elem[i].waittime=L.elem[i].starttime-L.elem[i].ptime;
L.elem[i].finishtime=L.elem[i].starttime+L.elem[i].runtime;
L.elem[i].turntime=L.elem[i].finishtime-L.elem[i].ptime;
L.elem[i].qtime=L.elem[i].turntime/L.elem[i].runtime;
}
i++;
}
}
（7）voidFPF（SqList&L）//高响应比法计算各个时间
{
inti=0;
while（i{
if（i==0）
{
L.elem[i].starttime=L.elem[i].ptime;
L.elem[i].finishtime=L.elem[i].starttime+L.elem[i].runtime;
L.elem[i].turntime=L.elem[i].finishtime-L.elem[i].ptime;
L.elem[i].qtime=L.elem[i].turntime/L.elem[i].runtime;
}
else
if（L.elem[i].ptime>=L.elem[i-1].finishtime）
{
L.elem[i].starttime=L.elem[i].ptime;
L.elem[i].finishtime=L.elem[i].starttime+L.elem[i].runtime;
L.elem[i].turntime=L.elem[i].finishtime-L.elem[i].ptime;
L.elem[i].qtime=L.elem[i].turntime/L.elem[i].runtime;
}
else
{
L.elem[i].starttime=L.elem[i-1].finishtime;
L.elem[i].waittime=L.elem[i].starttime-L.elem[i].ptime;
L.elem[i].finishtime=L.elem[i].starttime+L.elem[i].runtime;
L.elem[i].turntime=L.elem[i].finishtime-L.elem[i].ptime;
L.elem[i].qtime=L.elem[i].turntime/L.elem[i].runtime;
}
i++;
}
}
（8）voidDisplay（SqList&L）//输出函数，把顺序表中的数据输出
{
inti=0;
floatt1,t2;
t1=0;
t2=0;
cout<<"执行次序"<<while（i{
cout<<t1=t1+L.elem[i].turntime;
t2=t2+L.elem[i].qtime;
i++;
}
cout<<"平均周转周期为：
"<cout<<"平均带权周转周期为：
"<}
4.2.2.银行家算法的函数实现
（1）voidinput（intavailable[3],intmax[5][3],intallocation[5][3],intneed[5][3],intfinish[5],stringname[5]）//输入可利用资源数目，最大需求数目，以分配数目，需求数目，完成标记，进程名字
{
cout<<"请输入3种资源的数目";
for（intj=0;j<3;j++）
{
cin>>available[j];
}
for（inti=0;i<5;i++）
{
cout<<"请输入第"<cin>>name[i];
cout<<"请输入第"<for（intj=0;j<3;j++）
{
cin>>max[i][j];
}
cout<<"请输入第"<for（j=0;j<3;j++）
{
cin>>allocation[i][j];
}
for（j=0;j<3;j++）
{
need[i][j]=max[i][j]-allocation[i][j];
}
finish[i]=0;
}
}
（2）intfenpei（intavailable[3],intallocation[5][3],intneed[5][3],intfinish[5],intx
升级会员 