08级操作系统课程设计报告书副本文档格式.docx

08级操作系统课程设计报告书副本文档格式.docx

《08级操作系统课程设计报告书副本文档格式.docx》由会员分享，可在线阅读，更多相关《08级操作系统课程设计报告书副本文档格式.docx（49页珍藏版）》请在冰豆网上搜索。

staticintNeed[][];

//仍需资源数

staticintAvailable[];

//可利用资源数

staticStringname1[];

staticStringname2[];

staticboolean[]Finish;

staticint[]temp={0};

//存放安全序列

staticintwork[];

staticint[]Request;

Scannerinput=newScanner（System.in）;

publicstaticvoidmain（String[]args）{

Testt=newTest（）;

t.printFrame（）;

//t.print（）;

t.Safty（）;

t.judge（）;

}

/*输入初始化数据*/

publicvoidprintFrame（）

{

System.out.println（"

*****************************************************"

）;

System.out.println（"

**"

*银行家算法设计与实现*"

System.out.println（"

System.out.print（"

请输入系统中进程的个数:

"

no1=input.nextInt（）;

System.out.print（"

请输入资源的种类数：

no2=input.nextInt（）;

Max=newint[no1][no2];

Allocation=newint[no1][no2];

Need=newint[no1][no2];

Available=newint[no2];

name1=newString[no1];

name2=newString[no2];

intsum[]=newint[3];

for（inti=0;

i<

no1;

i++）

{System.out.print（"

请输入进程"

+i+"

的名字:

name1[i]=input.next（）;

no2;

请输入资源"

name2[i]=input.next（）;

{for（intj=0;

j<

j++）

{System.out.print（"

+name1[i]+"

的"

+name2[j]

+"

类资源最大需求量:

Max[i][j]=input.nextInt（）;

}

i++）

j++）

类资源已占有资源量:

Allocation[i][j]=input.nextInt（）;

Need[i][j]=Max[i][j]-Allocation[i][j];

}

for（inti=0;

请输入类资源"

+name2[i]+"

的可利用资源数：

Available[i]=input.nextInt（）;

{Available[i]=Available[i]-sum[i];

}

/*打印輸出*/

publicvoidprint（）

{System.out.println（"

**************此时刻资源分配情况**************"

NumberNameMaxAllocationNeed"

{System.out.print（"

"

+i+"

System.out.print（name1[i]+"

for（intj=0;

{System.out.print（Max[i][j]+"

for（intj=0;

+Allocation[i][j]）;

+Need[i][j]）;

System.out.println（）;

各个类资源可利用的资源数分别为:

+Available[j]）;

System.out.println（）;

}/**

*进行安全性检测

*/

publicvoidSafty（）{

Finish=newboolean[no1];

temp=newint[no1];

inti,k=0,m,apply,j;

//k为安全序列的序列数

intflag=0;

work=newint[no2];

for（i=0;

{work[i]=Available[i];

i++）//当前执行换后，重第一个开始检测

{apply=0;

for（j=0;

{if（Finish[i]==false&

&

Need[i][j]<

=work[j]）//

{apply++;

if（apply==no2）

{for（m=0;

m<

m++）

work[m]=work[m]+Allocation[i][m];

//变分配数

Finish[i]=true;

temp[k]=i+1;

//保存安全序列

i=-1;

//

k++;

flag++;

}

}

{if（Finish[i]==false）{System.out.println（"

系统不安全！

else

系统是安全的，安全序列为：

for（i=0;

i++）//输出运行进程数组

{System.out.print（temp[i]+"

-->

System.out.println（）;

print（）;

/*进行资源分配*/

publicvoidchangdata（inti）

{intj;

for（j=0;

{

Available[j]=Available[j]-Request[j];

Allocation[i][j]=Allocation[i][j]+Request[j];

Need[i][j]=Need[i][j]-Request[j];

/*利用银行家算法对申请资源对进行判定*/

voidjudge（）

Request=newint[no2];

charch='

y'

;

inti=0,j=0;

请输入您要分配的资源进程号：

for（j=0;

j<

10;

j++）

i=input.nextInt（）;

if（i>

no1）

{System.out.println（"

输入错误，请重新输入:

continue;

elsebreak;

//System.out.println（"

错误次数太多，看来您今天不适合进行操作，系统退出！

//System.exit（0）;

申请的资源：

System.out.print（name2[j]+"

类资源请求：

Request[j]=input.nextInt（）;

//输入需要申请的资源

if（Request[j]>

Need[i][j]）//判断申请是否大于需求，若大于则出错

{

System.out.println（"

进程"

申请的资源大于它所需要的资源。

分配不合理，不予分配！

ch='

n'

break;

}

else

if（Request[j]>

Available[j]）//判断申请是否大于当前资源，若大于则

{

System.out.println（"

申请的资源大于系统现在可利用的资源。

ch='

break;

if（ch=='

）

changdata（i）;

//根据进程需求量变换资源

Safty（）;

//根据进程需求量进行银行家算法判断

请输入您所要进行的操作：

1：

继续分配2：

退出"

for（i=0;

i<

5;

i++）

intchoice=input.nextInt（）;

if（choice==1）judge（）;

elseif（choice==2）System.exit（0）;

elseSystem.out.println（"

输入错误，请重新输入：

System.exit（0）;

1．6运行结果及分析

（可以抓取界面）

1.开始界面

2.初始化并打印输出

3.用例测试a：

进程1发出请求Request（2,1,2）——Request>

Need，不予分配。

4.用例测试b：

进程0发出请求Request（2,2,2）——Request>

Available，不予分配。

5.用例测试c：

进程1发出请求Request（1,0,1）——可以分配。

6.用例测试d：

进程0发出请求Request（1,0,1）——系统不安全。

7.输入测试a：

如果所输入的要分配资源的进程号不在存在的进

程，则报错请求重新输入。

8.输入测试b：

在选择继续分配还是退出中，如果输入不符合求，

则报错请求重新输入，连续错误5次后系统将自动关闭。

1．7心得体会

通过对此题目的研究，我基本达到了预期目标，编程模拟实现了银行家算法。

题目2磁盘调度算法的模拟

2．1题目的主要研究内容及预期达到的目标

模拟实现磁盘调度算法中的FCFS、SSTF、SCAN和CSCAN算法。

2．2题目研究的工作基础或实验条件

windows

VisualC++

2．3设计思想

用户输入当前磁头和磁道范围，随机的生成10个磁道数。

然后通过四种磁盘调度的模拟算法来显示出不同的方法调度后的磁道顺序。

开始生成的随机数列是字符串形式的，在每个算法过程中都要将其先转换成数组形式，然后将值赋给一个临时的数组。

总体思想是将数组逐一的相减得到磁道数，然后将整个数组向前移动一位。

计算出总磁道数和平均寻道长度。

在后面的两个算法中用到了冒泡排序将数组先按大小排序然后再处理。

最后将得到的数组结果再转换成字符串的形式输出。

在list控件中也显示出来，这样便于对这几种方法进行比较独处结论。

2．4流程图

（1）FCFS

（2）SSTF

（3）SCAN

（4）CSCAN

2．5主要程序代码

voidCTest04Dlg:

:

OnSc（）

{

//TODO:

Addyourcontrolnotificationhandlercodehere

（（CButton*）GetDlgItem（IDC_FCFS））->

EnableWindow（TRUE）;

//解除锁定

（（CButton*）GetDlgItem（IDC_SSTF））->

（（CButton*）GetDlgItem（IDC_SCAN））->

（（CButton*）GetDlgItem（IDC_CSCAN））->

m_ListCtrl.DeleteAllItems（）;

//列表清空

Jage=-1;

inti;

CStringran;

UpdateData（TRUE）;

Hand=m_Hand;

if（m_Limit>

65535||m_Limit<

=10||m_Hand>

65535||m_Hand<

=0）

MessageBox（"

超出范围!

else{

for（i=0;

=9;

DiscLine[i]=rand（）%m_Limit;

//随机生成10个磁道号

m_suiji="

{

ran.Format（"

%d"

DiscLine[i]）;

//将int类型转换为Cstring

m_suiji+=ran;

m_suiji+="

UpdateData（FALSE）;

OnFcfs（）

if（Jage>

=0）m_ListCtrl.DeleteAllItems（）;

Jage=0;

//TODO:

intRLine[10];

//将随机生成的磁道数数组Discline[]复制给数组RLine[]

intx,i,k,All,Temp;

//Temp是计算移动的磁道距离的临时变量all是计算总的移动磁头数

All=0;

//统计全部的磁道数变量

k=9;

//限定10个的磁道数

CStringran0;

i++）//复制磁道号到临时数组RLine

RLine[i]=DiscLine[i];

m_fcfssc="

All=Hand-RLine[0];

if（All<

0）All=（-All）;

Temp=RLine[0]-RLine[1];

//求出移动磁道数,前一个磁道数减去后一个磁道数得出临时的移动距离

if（Temp<

0）

Temp=（-Temp）;

//移动磁道数为负数时,算出相反数作为移动磁道数

ran0.Format（"

RLine[0]）;

//将int类型转换为Cstring

m_fcfssc+=ran0+"

All=Temp+All;

//求全部磁道数的总和

//每个磁道数向前移动一位

x=0;

for（inta=x;

a<

k;

a++）

{

RLine[a]=RLine[a+1];

x++;

k--;

}

m_zfcfs=All;

m_a=（float）（All）/10;

BIJIAOsc;

Jage+1）;

//它是以"

%"

开始,而以type结束.d十进制数，表示一个整型值

sc.code=ran0;

sc.name="

FCFS"

sc.shunxu=m_fcfssc;

m_zfcfs）;

sc.daxiao=ran0;

%f"

m_a）;

sc.pingjun=ran0;

show（sc）;

OnSstf（）//最短寻道时间优先

{//TODO:

Jage=1;

intHan=Hand;

intx,i,j,k,h,All;

intTemp;

//Temp是计算移动的磁道距离的临时变量

intMin;

//设置一个大数作为存放最小的磁道数差

CStringran1;

{RLine[i]=DiscLine[i];

m_sstfsc="

{Min=64000;

=k;

j++）//内循环寻找与当前磁道号最短寻道的时间的磁道号

{if（RLine[j]>

Han）//如果第一个随机生成的磁道号大于当前的磁道号，执行下一句

Temp=RLine[j]-Han;

//求出临时的移动距离

else

Temp=Han-RLine[j];

Min）//如果每求出一次的移动距离小于Min，执行下一句

{Min=Temp;

//Temp临时值赋予Min

h=j;

//把最近当前磁道号的数组下标赋予h

All=All+Min;

//统计一共移动的距离

ran1.Format（"

RLine[h]）;

m_sstfsc+=ran1+"

Han=RLine[h];

//将当前选出的数当作开头，与其他数做比较

x=h;

a++）//从当前已经选出的位置起，每个磁道数向前移动一位

{RLine[a]=RLine[a+1];

m_zsstf=All;

m_b=（float）（All）/10;

sc.code=ran1;

SSTF"

sc.shunxu=m_sstfsc;

m_zsstf）;

sc.daxiao=ran1;

m_b）;

sc.pingjun=ran1;

OnScan（）

{//TODO:

Jage=2;

CStringran2;

inttemp;

intk=1;

intl,r;

//相对描述磁道Hand在位置

inti,j,sum=0;

UpdateData（）;

xiangnei=m_xiangnei;

if（xiangnei==1）Jage=3;

for