计算机操作系统实训报告

目录

任务一2

任务二4

任务三13

任务四19

任务五25

实训总结36

任务一分析操作系统所面临的操作需求

【实训目的】

让学生可以更好的理解、掌握和应用操作系统中的进程管理、存储管理、设备管理和文

件管理等功能。

【实训内容】

1.熟悉实训环境；

2.分析操作系统的操作需求；

3.资料搜集与整理，进行实训的前期准备。

【实训步骤】

1.分析与设计

模拟操作系统

进程管理存储管理

先

两

生产者与消最

进程调度

进

近

费者问题种

先

最

淘

出

少

汰

先短高

淘

使M

来作优

汰

用

法

先业

先算

淘

比

服优权法

汰

较

务先优算

尊算先法

法法篇

法

2

图IT实训总体结构图

【思考题】

1.操作系统中各模块有怎样的功能？

答：进程管理模块用于分配和控制处理机；设备管理模块主要负责对I/O设备的分

配与操纵；文件管理模块主要负责文件的存取、共享和保护；存储管理模块主要负责的

分配与回收。

2.它们之间有怎样的联系？

答：设备管理、文件管理和储存管理都需要进程的管理；文件需要文件管理进行存

储，同时也需要储存管理来对文件存储分配空间等等。

3.针对某一特定的应用环境，如何完善操作系统的功能？

答：要想完善操作系统的功能，必须要合理安排各个功能模块，并利用有效的算法

对各个功能进行管理和处理。

任务二进程管理

【实训目的】

掌握临界区的概念及临界区的设计原则；掌握信号量的概念、PV操作的含义以及应用P

V操作实现进程的同步与互斥；分析进程争用资源的现象，学习解决进程互斥的方法；掌握

进程的状态及状态转换；掌握常用的进程调度算法。

【实训内容】

1.分析进程的同步与互斥现象，编程实现经典的进程同步问题——生产者消费者问题的

模拟；

2.编写允许进程并行执行的进程调度程序，在常用的进程（作业）调度算法：先来先服

务算法、短作业优先算法、最高响应比优先算法、高优先权优先算法等调度算法中选择种

调度算法进行简单模拟，并输出平均周转时间和平均带权周转时间。

3

【实训步骤】

一.生产者与消费者问题

1.分析与设计

图2-1生产者与消费者问题分析图

2.程序代码

^include<windows.h>

#include<iostream>

constunsignedshortBUFFER=5;〃缓冲区长度

unsignedshortProductID=0;〃产品号

unsignedshortConsumelD=0;//将被消耗的产品号

unsignedshortin=0;//产品进缓冲区时的缓冲区产品个数

4

unsignedshortout=0;〃产品出缓冲区时的缓冲区产品个数

intg_buffer[BUFFER];〃缓冲区为循环队列

boolg_continue=true;〃控制程序结束

HANDLEg_hMutex;//线程间互斥对像

HANDLEg_hFullSemaphore;〃满则生产者等待

HANDLEg_hEmptySemaphore;〃空则消费者等待

DWORDWINAPIProducer(LPVOID);//生产者线程

DWORDWINAPIConsumer(LPVOID);〃消费者线程

〃主程序

intmain()

(

〃创建各个互斥信号

g_hMutex=CreateMutex(NULL,FALSE,NULL);

g_hFu11Semaphore=CreateSemaphore(NULL,BUFFER-1,BUFFER-1,NULL);

g_hEmptySemaphore=CreateSemaphore(NULL,0,BUFFER-1,NULL);

constunsignedshortPRODUCERS_COUNT=2;//生产者的个数

constunsignedshortCONSUMERS_COUNT=1;〃消费者的个数

〃总的线程数

constunsignedshortTHREADS_COUNT=PRODUCERS工OUNT+CONSUMERS_COUNT;

HANDLEhThreads[PRODUCERS_COUNT];〃各线程的handle

DWORDproducerlD[CONSUMERSCOUNT];〃生产者线程的标识符

DWORDconsumerID[THREADS_COUNT];〃消费者线程的标识符

〃创建生产者线程

for(inti=0;i<PRODUCERSCOUNT;++i)

hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);

if(hThreads[i]==NULD

return-1;

)

〃创建消费者线程

for(i=0;iCONSUMERSCOUNT;++i)

(

hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);

if(hThreads[i]==NULL)

return-1;

)

while(g_continue)

(

if(getchar())

(

gcontinue=false;〃按回车后终止程序运行

}

)

return0;

}

〃生产一个产品，把新生产的产品放入缓冲区

voidProduce()

5

std::cerr«〃生产产品〃«++ProductID<<std::endl;

std::cerr<<“将新的产品”;

g_buffer[in]=ProductID;

in=(in+l)%BUFFER;

std::cerr«〃放入缓冲区"«std::endl;

〃输出缓冲区当前的状态

for(inti=O;i<BUFFER;++i)

(

std::cout«i<<〃：〃<<g_buffer[i];

if(i二二in)std::cout«〃=生产〃；

if(i==out)std::cout«〃一消费〃；

std::cout«std::endl;

)

)

〃从缓冲区中取出一个产品，并将其消耗

voidConsume()

(

std::cerr«〃从缓冲区中取出产品〃；

ConsumelD=g_buffer[out];

out=(out+l)%BUFFER;

std::cout«std::endl;

〃输出缓冲区当前的状态

for(inti=0;i〈BUFFER;++i)

(

std::cout«i<<":〃«g_buffer[i];

if(i==in)std::cout«〃一壬产〃；

if(i==out)std::cout«〃一消费”;

std::cout«std::endl;

)

std::cerr«〃消耗一个产品〃<<ConsumelD«std::endl;

)

〃生产者

DWORDWINAPIProducer(LPVOIDIpPara)

(

while(gcontinue)

(

WaitForSingleObject(ghFullSemaphore,INFINITE);

WaitForSingleObject(g_hMutex,INFINITE);

Produce0;

Sleep(1500);〃此处以毫秒为单位

ReleaseMutex(g_hMutex);

ReleaseSemaphore(ghEmptySemaphore,1,NULL);

)

return0;

)

〃消费者

DWORDWINAPIConsumer(LPVOIDIpPara)

while(g_continue)

6

WaitForSingleObject(g_hEmptySemaphore,INFINITE);

WaitForSingleObject(g_hMutex,INFINITE);

Consume();

Sleep(1500);〃此处以毫秒为单位

ReleaseMutex(ghMutex);

Re1easeSemaphore(g_hFu11Semaphore,1,NULL);

)

return0;

)

3.程序运行截图

1•C:\Users\LErnNG\De$ktop\Debug浮扬,exe*

3：4

4：5y消费

道耗一个产品4

生产产品7

将新的产品放入缓冲区

06

17

E

3-胡

5-消费

缓冲区中里出产品

6*-宿费

7

3*-胡

4

澧耗一个产品5

生产产品8

将新的产品放入缓冲区

0：6一消费

1：7

2：8

3：46生产

图2-2生产者与消费者问题运行截图

7

先来先服务算法

1.分析与设计

图2-3先来先服务算法设计图

2.程序代码

ttinclude<stdio.h>

〃定义进程的结构体

structfcfs

charname[10];〃进程名称

intpriority;〃进程优先数

floatarrivetime;〃到达时间

floatservicetime;〃运行时间

floatstarttime;〃开始时间

floatfinishtime;〃完成时间

floatreturntime;〃周转时间

floatwreturntime;〃带权周转时间

8

);

fcfsa[50];

〃程序的输入显示及提示

voidinput(fcfs*p,intN)

(

inti;

printf(〃请依次输入进程名称一到达时间一运行时间一进程优先数:\n〃)；

for(i=0;i<=N-l;i++)

(

printf(z，\n输入%d号进程信息:\n〃,i+1);

scanf&p[i].name,&p[i].arrivetime,&p[i].servicetime,priority);

)

)

〃程序的输出显示

voidPrint(fcfs*p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,floa

treturntime,floatwreturntime,intpriority,intN)

(

intk;

printf(〃运行指令：〃)；

printf(〃％s〃,p[0].name);

for(k=l;k<N;k++)

(

printfp[k].name);

)

printf(，z\n进程信息：\n〃);

printfC\n进程\t到达\t运行\t开始\t结束\t周转\t带权周转进程优先数\n〃)；

for(k=0;k<=N-l;k++)

(

printf(，z%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%~.2f\t%-.2f\t\t%d\n〃，p[k].name,p[k].arr

ivetime,p[k].servicetime,p[k].starttime,p[k].finishtime,p[k].returntime,p[k].wretu

rntime,p[k].priority);

)

)

〃排序采用冒泡排序法进行排序，排序顺序从小到大

voidsort(fcfs*p,intN)

(

for(inti=0;i<=N-l;i++)

for(intj=0;j<=i;j++)

if(p[i].arrivetime<p[j],arrivetime)

(

fcfstemp;

temp=p[i];

p[i>p[jL

p[j]=temp;

)

)

〃运行阶段

voidfunciton(fcfs*p,floatarrivetime,floatservicetime,floatstarttime,floatfinishtime,

float&returntime,float&wreturntime,intpriority,intN)

9

intk;

for(k=0;k<=N-l;k++)

(

if(p[k].arrivetime>p[k-l].finishtime)

{

p[k].starttime=p[k].arrivetime;

p[k].finishtime二p[k].arrivetime+p[k].servicetime;

)

else

{

p[k].starttime=p[k-l].finishtime;

p[k].finishtime=p[k-1].finishtime+p[k].servicetime;

)

)

for(k=0;k<=N-l;k++)

(

p[k].returntime=p[k].finishtime-p[k].arrivetime;

p[k].wreturntime=p[k].returntime/p[k].servicetime;

)

)

〃模拟操作系统的先来先服务算法

voidFCFS(fcfs*p,intN)

(

floatarrivetime=O,servicetime=O,starttime=O,finishtime=O,returntime=O,wreturntime=O,pr

iority=0;

sort(p,N);

funciton(p,arrivetime,servicetime,starttime,finishtime,returntime,wreturntime,priority,

N);

Print(p,arrivetime,servicetime,starttime,finishtime,returntime,wreturntime,priority,N);

)

〃主函数

voidmain()

(

intN;

printf(〃\t\t\t进程调度之先来先服务调度算法\n〃)；

printf(〃请输入进程数:\n〃)；

scanf&N);

input(a,N);

FCFS(a,N);

10

3.程序运行截图

图2-4先来先服务调度算法运行截图

【思考题】

1.针对某一具体应用环境，如何选择合适的调度算法？

答：应根据具体情况来选用合适的调度算法。比如，在批处理系统中，为了照顾为

数众多的短作业，应采用短作业优先调度的调度算法；在分时系统中，为了保证系统具

有合理的响应时间，应采用轮转法进行调度。非抢占式调度算法，有利于长作业，不利

于短作业。

11

任务三存储管理

【实训目的】

掌握物理内存和虚拟内存的基本概念；掌握重定位的基本概念及其要点，理解逻辑地址

与绝对地址；掌握各种存储管理的实现方法，包括基本原理、地址变换和缺页中断、主存空

间的分配及分配算法；掌握常用淘汰算法。

【实训内容】

编写一个模拟的动态页式存储管理程序，实现对动态页式存储的淘汰算法的模拟（在先

进先出淘汰算法、最近最少使用淘汰算法、最不经常使用淘汰算法三种算法中选择一种进行

模拟）并计算各个算法的缺页率；并且页面淘汰算法在淘汰一页时，只将该页在页表中抹去,

而不再判断它是否被改写过，也不将它写回到辅存

【实训步骤】

1.分析与设计

设置一个后进先出栈，栈大小为分配给这个进程的页面数。在在系统中设定一个计数器,

进程进程进行访问内页面操作都把计数器的值加1,把结果值赋值给访问的页面，在淘汰页

面时选择计数器值最小的页面淘汰。这样的栈顶上总是保存着最近被访问的页面号，而栈底

保存的就是最近最久没有被访问的页面号。如图3-1所示

12

图37最近最久未使用置换算法分析图

2.程序代码

^include<stdio.h>

ttinclude<stdlib.h>

〃最近最久未使用置换算法

〃参数说明:P地址流,n地址流的个数,pageSize页面大小，pageTable页表,count页表大小

voidLRU(intp[],intn,intpageSize,intpageTable[],intcount)

(

inti,pageNo,j,pagecount,k;

floatsum;

int*stack=(int*)malloc(sizeof(int)*count);

pagecount=0;

k=0;

sum=0;

system(〃cls〃);

13

printf(，z\n\n\t\t\t存储管理--最近最少使用淘汰算法\n\n〃)；

for(i=0;i<n;i++)

(

pageNo=p[i]/pageSize;

printf(〃\t\t调入页号%d后\t〃，pageNo);

printf(〃\t\t页表:〃)；

for(j=0;j<pagecount;j++)〃判断页号是否在页表中

(

if(pageNo==pageTable[j])〃如果页号在页表中

{

for(k=0;k<count;k++)〃设置栈中各页面使用情况

(

if(stack[k]==pageNo)

(

if(k!=count-1)

(

for(;k<count-1;k++)

(

stack[k]=stack[k+1];

)

stack[k]=pageNo;

)

)

)

break;

)

)

〃页号不在页表中，插入页表

if(j==pagecount)

(

〃如果页表不满

if(pagecount<count)

(

pageTable[pagecount++]=pageNo;

stack[pagecount-1]=pageNo;

)

〃如果页表已满

else

(

for(j=0;j<count;j++)

(

if(pageTable[j]==stack[0])

(

pageTable[j]=pageNo;

for(k=0;k<count-1;k++)〃设置栈中各页面使用情况

(

stack[k]=stack[k+1];

14

stack[k]=pageNo;

break;

)

)

)

sum++;〃缺页数

)

〃打印页表

for(j=0;j<count;j++)

(

if(pageTable[j]>=0)

(

printf("%d〃，pageTable[j]);

)

)

printf(〃\n〃)；

)

sum/=n;

sum*=100;

printf("\t\t\t缺页率:%.lf%%\n\nz，,sum);

free(stack);

}

voidmain()

(

intn,pageSize=1024,pageTable[3];

int*p,i;

FILE*fp;

system(〃cls〃);

printf(，z\n\n\t\t\t存储管理—最近最少使用淘汰算法\n\n\n〃)；

printf(〃请确认在\"Address.txt\〃文件中已输入地址流.\n〃);

printf(〃如果没有，请自行新建后再运行.\n\n\n\n〃)；

system("pause");

if((fp=fopen("Address.txt",〃r+〃))==NULL)

(

printf(〃打开文件出错!\n〃)；

system("pause");

return;

)

fscanf(fp,〃%d〃，&n);

p=(int*)malloc(sizeof(int)*n);

printf("\n\n\n读取到以下的地址流:\n〃);

for(i=0;i<n;i++)

15

fscanf(fp,"%d”,&p[i]);

printf(〃%d〃，p[i]);

)

printf(〃\n\n〃)；

fclose(fp);

system("pause");

system(〃cls〃)；

LRU(p,n,pageSize,pageTable,3);

)

3.程序运行截图

图3-2最近最久未使用置换算法程序截图

16

■C:\U5R0LETnNG\Desktop\Debug序稼exe,

存储管理--最近最少使用淘汰算法

入

表

调

页号

页0

入

表

调

号0.3

-页03

页

入

调

表

号2032

-页

入

调

表

号1132

页-

页

调入

表

号-2132

词入

号

表

页

0页102

调

入

号

1表102

页

页-

调

入

号

7表107

,.页

调

号

入

0表107

页-

页7

谓10

号

入

1表

龈

率

60.0z

Pressan9keytocontinue

图3-3最近最久未使用置换算法程序截图

【思考题】

1.各种不同的页面淘汰算法有哪些优缺点？为什么会产生页面抖动？什么是belady

现象？这种现象该如何避免？

答：最佳值换算法其所选择的被淘汰页将是以后用不适用的，或许是在最长（未来）

时间内不再被访问的页面。采用最佳值换算法通常可保证获得最低的缺页率。但是由于

人们目前还无法预知一个进程在内存的若干个页面中，哪一个页面是未来最长时间内不

再被访问的，因此该算法是无法实现的，但可以利用该算法去评价其它算法。先进先出

置换算法（FIFO）是最直观的算法，由于它可能是性能最差的算法，故实际应用极少。

最近最久未使用置换算法（LRU）虽然是一种比较好的算法，但要求系统有较多的支持硬

件。

因为刚被淘汰出去的页，过后不久又要访问它，需要再次调入，而调入后不久又再

次被淘汰，然后又要访问，如此反复，使得系统的把大部分时间用在页面的调进调出上,

这种形象称为“抖动”。

随着物理块数的增多缺页率增大，从而造成Belady异常现象。尽量避免物理块数不

断增多缺页率最大。

17

任务四设备管理

【实训目的】

掌握独占设备的使用方式，以及设备的分配和回收；掌握用死锁避免方法来处理申请独

占设备可能带来死锁。

【实训内容】

用死锁避免方法来处理申请独占设备可能造成的死锁，程序实现对银行家算发的模拟。

【实训步骤】

1、分析与设计

1.1、银行家算法：

设进程x提出请求Request[y],则银行家算法按如下规则进行判断。

(1)如果Request[y]>Need[x,y],则报错返回。

⑵如果Request[y]>Available,则进程i进入等待资源状态，返回。

(3)假设进程n的申请已获批准，于是修改系统状态：

Available=Available-Request

Allocation=Allocation+Request

Need=Need-Request

(4)系统执行安全性检查，如安全，则分配成立；否则试探险性分配作废，系统恢复原状,

进程等待。

1.2.安全性检查：

(1)设置两个工作向量Work=Available；Finish[z]=False

(2)从进程集合中找到一个满足下述条件的进程，

Finish[x]=False

Need<=Work

如找到，执行(3)；否则，执行(4)

(3)设进程获得资源，可顺利执行，直至完成，从而释放资源。

Work=Work+Allocation

Finish=True

18

GOTO2

(4)如所有的进程Finish[z]=true,则表示安全；否则系统不安全

1.3银行家算法实现流程图，如图4T所示。

图4-1银行家算法实现流程图

2、程序代码

ttinclude<string.h>

#include<stdio.h>

ttinclude<stdlib.h>

#defineX5〃总进程数

ttdefineY3〃总资源数

〃银行家算法定义结构体

structbanker

intmax[X][Y];〃最大需求矩阵

intallocation[X][Y];〃分配矩阵

intneed[X][Y];〃需求矩阵

19

intavailable[Y];〃可利用资源向量

)；

〃初始化

voidinitilize(banker&x)

inti,j;

printf(“请输入数据(系统设定总进程数为5,总资源数为3):\n");

printf("最大需求矩阵:\n");

for(i=0;i〈X;i++)〃设置最大需求矩阵

(

for(j=0;j<Y;j++)

(

scanf&x.max[i][j]);

)

)

printf("分配矩阵:\n");

for(i=0;i<X;i++)//设置分配矩阵

(

for(j=0;j<Y;j++)

(

scanf("%d”,&x.allocation[i][j]);

)

for(i=0;i<X;i++)〃设置需求矩阵

for(j=0;j<Y;j++)

{

x.need[i][j]=x.max[i][j]-x.allocation[i][j];

)

)

printf(〃可利用资源向量:\n");

for(i=0;i<Y;i++)〃设置可利用资源向量

scanf&x.available[i]);

)

〃检查安全性

intsafe(bankerx)

(

inti,j;

intsafeprocess[X];〃安全序列向量

intwork[Y];〃空闲资源矩阵

intFinish[X];〃进程完成标志矩阵

for(i=0;i〈Y;i++)〃开始时可利用资源向量就是空闲资源矩阵

work[i]=x.avaiTable[i];

for(i=0;i<X;i++)//初始化标志矩阵为false

Finish[i]=false;

intk=0;〃安全序列排列号

for(i=0;i<X;i++)〃每次都从第一个进程开始做循环

20

if(Finish[i]==false)

(

for(j=0;j<Y;j++)

(

if(x.need[i][j]>work[j])〃判断当前进程需求矩阵能否得到满足

break;〃不满足则跳出

)

if(j=Y)〃第i个进程满足执行条件

(

safeprocess[k++]=i;〃将进程号存入安全序列向量

for(intq=0;q<Y;q++)〃修改空闲资源矩阵

work[q]+=x.allocation[i][q];

Finish[i]=true;〃标志该进程可完成

i=-1；〃下次检查从第一个进程重新查起

)

)

)

for(i=0;i<X;i++)〃检查标志数组，若有一个为false则找不到安全序列

if(!Finish[i])

(

printf(〃无法找到安全序列,系统处于不安全状态!\n〃)；

return0;

)

printf(〃安全序列为:〃)；〃找到安全序列并显示该序列

for(i=0;i<X;i++)

printf(z/%d号进程〃，safeprocess[i]+l);

printf(〃\n〃)；

return1;

)

〃系统对进程资源申请的处理

voidallocate(banker&x)

bankertemp=x;〃临时变量存储x的初值

intRequest[Y];〃请求向量

intnumber;〃进程号

inti;

printf(〃请输入要申请资源的进程序号:\n〃)；

scanf("%d〃,&number);

printf(〃请输入请求向量:\n〃);

for(i=0;i<Y;i++)

scanf(〃％d〃,&Request[i]);〃输入请求向量

for(i=0;i<Y;i++)

(

if(Request[i]>x.need[numberT][i])〃所需资源数大于需求量

(

printf(〃错误！进程所需要的资源数已超过最大值。\n〃)；

return;

21

if(Request[i]>x.available[i])//所需资源数大于可利用资源

printf（"错误！系统中没有足够的资源满足进程的申请。\n"）;

return;

}

)

for(i=0;i<Y;i++)〃假设系统将申请资源数分配给该进程，对数据进行相关修改

(

x.available"]Request[i];

x.need[number-1][i]-=Request[i];

x.allocationLnumber-1][i]+=Request[i];

)

if(safe(x))〃安全性检查结果为安全

(

printf("系统可以为该进程分配资源.\n");

return;

）

else//安全性检查结果为不安全

（

printf（"系统不为该进程分配资源\n"）;

x=temp;〃将相关矩阵修改过来，表示资源不分配资源

return;

)

}

〃主程序

voidmain(void)

(

bankercurrent;〃定义变量

initilize(current);〃初始化

safe(current);〃检查安全性

while(l)〃循环执行进程申请资源和系统对申请的处理

allocate(current);

)

}

22

3、运行并测试程序，并给出程序运行界面。

**G\Users\LEmNG\Desktop\D<

图4-2银行家算法运行截图

【思考题】

1.如果产生了死锁，应如何解除？

答：当发现有死锁时，便应立即把它们从死锁状态中解脱出来。常采用解除死锁的

两种方法是：

(1)剥夺资源。从其它进程剥夺足够数量的资源给死锁进程，以解除死锁状态。

(2)撤销进程。最简单的撤销进程的方法是使全部死锁状态进程都夭折掉；稍微温和一点的方法

是按照某种顺序逐个的撤销进程，直至有足够的资源可用，使死锁状态消除为止。

23

任务五文件管理

【实训目的】

掌握文件的存取方法；掌握文件的逻辑结构和物理结构；掌握存储空间的分配和回收；

掌握磁盘管理与调度。

【实训内容】

用程序模拟磁盘的调度过程，并计算各磁盘调度算法包括先来先服务算法、最短寻道时

间优先算法、扫描算法和循环扫描算法的平均寻道长度。

【实训步骤】

1、分析与设计

图5-1先来先服务算法流程图

24

图5-2最短寻道时间算法流程图

25

图5-3扫描算法流程图

2、程序代码

#include〃stdio.h〃

#include"stdlib.h〃

intNAI1=0;

intBest[5][2];〃用作寻道长度由低到高排序时存放的数组

intLimit=0;〃输入寻找的范围磁道数i

intJage;

floatAver=0;

〃数组Sour复制到数组Dist,复制到x个数

26

voidCopyL(intSour[],intDist[],intx)

(

inti;

for(i=0;i<=x;i++)

(

Dist[i]=Sour[i];

)

}

〃打印输出数组

voidPrint(intPri[],intx)

(

inti;

for(i=0;i<=x;i++)

(

printf(飞5d”,Pri[i]);

)

)

〃随机生成磁道数

voidSetDI(intDiscL[])

(

inti;

for(i=0;i〈=9;i++)

(

DiscL[i]=rand()%Limit;//随机生成10个磁道号

)

system("cis");

printfC\n\n\n需要寻找的磁道号：”)；

Print(DiscL,9);〃输Hl随机生成的磁道号

printf("\n");

)

〃数组Sour把x位置的数删除，并把y前面的数向前移动

voidDellnq(intSour[],intx,inty)

(

inti;

for(i=x;i<y;i++)

(

Sour[i]=Sour[i+l];

x++;

)

}

〃先来先服务算法(FCFS)

voidFCFS(intHan,intDiscL口)

{

intRLine[10];〃将随机生成的磁道数数组Disci口复制给数组RLine口

inti,k,AH,Temp;〃Temp是计算移动的磁道距离的临时变量

All=0;〃统计全部的磁道数变量

k=9;〃限定10个的磁道数

CopyL(DiscL,RLine,9);〃复制磁道号到临时数组RLine

printfC\n按照FCFS算法磁道的访问顺序为：”)；

27

All=Han-RLine[0];

for(i=0;i<=9;i++)

(

Temp=RLine[O]-RLine[l];〃求出移动磁道数,前一个磁道数减去后一个磁道数得出临时的移动

距离

if(Temp<0)

Temp=(-Tenip);〃移动磁道数为负数时，算出相反数作为移动磁道数

printf("%5d”,RLine[0]);

All=Temp+Al1;〃求全部磁道数的总和

Dellnq(RLine,0,k);〃每个磁道数向前移动一位

k—;

)

Best[Jage][1]=A11;//Best[][1]存放移动磁道数

Best[Jage][0]=l;//Best口[0]存放算法的序号为：1

Jage++;〃排序的序号加1

Aver=((float)Al1)/10;〃求平均寻道次数

printf("\n移动磁道数:〈%5d>”,All);

printfC\n平均寻道长度:*%0.2f*",Aver);

)

〃最短寻道时间优先算法(SSTF)

voidSSTF(intHan,intDiscL[])

(

inti,j,k,h,All;

intTemp;〃Tenip是计算移动的磁道距离的临时变量

intRLine[10];〃将随机生成的磁道数数组Disci口复制给数组RLine口

intMin;

All=0;〃统计全部的磁道数变量

k=9;〃限定10个的磁道数

CopyL(DiscL,RLine,9);〃复制磁道号到临时数组RLine

printfC\n按照SSTF算法磁道的访问顺序为：");

for(i=0;i<=9;i++)

(

Min=64000;

for(j=0;j<=k;j++)〃内循环寻找与当前磁道号最短寻道的时间的磁道号

(

if(RLine[j]>Han)〃如果第一个随机生成的磁道号大于当前的磁道号，执行下一句

Temp=RLine[j]-Han;//求出临时的移动距离

else

Temp=Han-RLine[j];〃求出临时的移动距离

if(Temp<Min)〃如果每求出一次的移动距离小于Min,执行下一句

(

Min=Temp;〃Temp临时值赋予Min

h=j;〃把最近当前磁道号的数组下标赋予h

}

)

A11=A11+Min;〃统计一共移动的距离

printf("%5d”,RLine[h]);

Han=RLine[h];

Dellnq(RLine,h,k);〃每个磁道数向前移动-一位

28

k-

Best[Jage];〃Best□[1]存放移动磁道数

Best[Jage][0]-2;//Best[][0]存放算法的序号为:2

Jage++;〃排序序号加1

Aver=((float)All)/10;〃求平均寻道次数

printf("\n移动磁道数:<%5d>",All);

printf("\n平均寻道长度:*%0.2f*”,Aver);

)

〃扫描算法(SCAN)

intSCAN(intHan,intDiscL[],intx,inty)

(

intj,n,k,h,m,All;

intt=0;

intTemp;

intMin;

intRLine