2020年计算机操作系统课程设计报告

计算机操作系统课程设计报告

修4城*孝

《操作系统原理》

实验报告

院（部）：管理工程学院

专业：信息管理与信息

系统

实验项目：实验一二三

五

班级：信管102

姓名：张凤丹

文档仅供参考，不当之处，请联系改正。

学号：021418

目录

弓I言................................6

实验一、模拟进程创立、终止、阻塞、唤醒原语

...................................................................................9

实验目的：......................9

实验内容：.........................10

实验步骤：.........................10

实验代码：.........................11

程序运行结果及分析.................24

实验感想:..........................24

实验二、模拟进程调度功能...............26

实验目的：.........................26

实验内容：.........................26

实验步骤：.........................27

实验代码：.........................28

程序运行结果及分析.................37

实验感想:..........................38

实验三：模拟动态分区首次适应分配和回收算法

.................................................................................38

实验目的：.....................38

文档仅供参考，不当之处，请联系改正。

实验内容：.........................38

实验步骤：.........................39

实验代码：.........................39

程序运行结果及分析.................53

实验感想:..........................54

实验五：模拟使用银行家算法判断系统的状态55

实验目的：.........................55

实验步骤：.........................55

实验代码：.........................55

程序运行结果及分析.................66

实验感想:..........................67

文档仅供参考，不当之处，请联系改正。

引言

操作系统是信息管理与信息系统专业一门

重要的专业理论课程，了解和掌握操作系统的基

本概念、功能和实现原理，对认识整个计算机系

统的工作原理十分重要。

操作系统实验是操作系统课程的一个重要组成

部分，经过试验环节的锻炼使同学们不但能够对

以前的所学过的基础知识加以巩固，同时能够经

过上机实验，对操作系统的抽象理论知识加以理

解，最终达到融会贯通的目的，因此，实验环节

是同学们理解、掌握操作系统基本理论的一个重

要环节。

本实验指导书，根据教材中的重点内容设定了相

应的实验题目，由于实验课程的学时有限，我们

规定了必做题目和选做题目，其中必做题目必须

在规定的上机学时中完成，必须有相应的预习报

告和实验报告。选做题目是针对有能力或感兴趣

的同学利用课余时间或上机学时的剩余时间完

成。

文档仅供参考，不当之处，请联系改正。

文档仅供参考，不当之处，请联系改正。

文档仅供参考，不当之处，请联系改正。

实验一、模拟进程创立、终止、阻塞、唤

醒原语

实验目的：

经过设计并调试创立、终止、阻塞、唤

醒原语功能,有助于对操作系统中进程控制

功能的理解,掌握操作系统模块的设计方法

和工作原理。

文档仅供参考，不当之处，请联系改正。

实验内容：

1、设计创立、终止、阻塞、唤醒原语功能函

数。

2、设计主函数，采用菜单结构（参见后面给

出的流程图）。

3、设计“显示队列”函数，目的能将就绪、

阻塞队列中的进程信息显示在屏幕上，以

供随时查看各队列中进程的变化情况。

实验步骤：

1、进程PCB中应包含以下山家•

2、系统总体结构：

I^^台

系统主菜单

文档仅供参考，不当之处，请联系改正。

1…创立

2…阻塞

3…唤醒

4…终止

5…显示

0…退出

请输入您需要

的功能（0

—5）：

退出创立阻塞唤醒终止显示

［结束

实验代码：

#include<stdio.h>

#include<string.h>

structPCB

文档仅供参考，不当之处，请联系改正。

charname[4];

intpriority;

intruntime;

）；

voidmain（）

（

intx,t；

inta=0;

intk=0,r=l,i=0,j=0;//k为就绪队列总数，r堵

塞队列总数

charname[4];

structPCBpcb[10];

structPCBpcbl[10];

structPCBpcb2[10];

printf（n...........................菜单

...........................\n\n\nn）;

printf（"0-退出系统\n"）;

printf「L…创立进程\n”）;

文档仅供参考，不当之处，请联系改正。

printf("2--堵塞进程\n”);

printf("3--唤醒进程W”);

printf(”4--终止进程\n")；

printf("5.…显示进程\n");

printf(M...................................................................\nM

）；

strcpy(pcb1[0].nameJs'');〃堵塞队歹l|

pcbl[0].priority=2;

pcbl[0].runtime=3;

//printf(n%s%d%dH,pcbl[O].name,pcbl[

0].priority,pcb1[0].runtime);

while(l)

(

printf("请输入你的选择;

scanf(H%dn,&x);

if(x==0)

文档仅供参考，不当之处，请联系改正。

break;

if(x==l)

printf(u.......................创立进程

..........\n")；

printf("进程名：”)；

scanf(n%sn,&pcb[k].name);

printf("优先级：”);

scanf(n%dn,&pcb[k].priority);

printf("运行时间:")；

scanf(n%dn,&pcb[k].runtime);

k=k+l;

)

if(x==2)

(

printf(H...................堵塞进程

文档仅供参考，不当之处，请联系改正。

.....................\nH);

printf("请输入要查找的进程：")；

scanf(n%sn,name);

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

(

if(strcmp(pcb[j].name,name)==O)

{

t=j；

strcpy(pcb2[a].name,pcb[t].name);

pcb2[a].priority

pcb[t].priority;

pcb2[a].runtime

pcb[t].runtime;

strcpy(pcbl[r].name,pcb2[a].name);

pcbl[r].priority

pcb2[a].priority;

pcbl[r].runtime

pcb2[a].runtime;

文档仅供参考，不当之处，请联系改正。

r=r+l;

a=a+l;

for(i=t;i<=k;i++)

(

strcpy(pcb[i].name,pcb[i+1].name);

pcb[i].priority=

pcb[i+l].priority;

pcb[i].runtime=

pcb[i+l].runtime;

)

k=k-l;

printfC将就绪序列调度为运行：”);

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

printf(n%s%d%d\nn,pcb2[i].name,pcb2[i].p

riority,pcb2[i].runtime);

printf("堵塞进程：\nH);

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

printf(n%s%d%d\nn,pcbl[j].name,pcbl[j].

文档仅供参考，不当之处，请联系改正。

priority,pcbl[j].runtime);

break;

)

else

printf("该进程已是堵塞进程!\n“);

break;

)

)

if(x==3)

文档仅供参考，不当之处，请联系改正。

printf(n........................唤醒进程

.....................W)；

printfC请输入要唤醒的进程：")；

scanf(n%sn,name);

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

(

if(strcmp(pcbl[i].name,name)==O)

|

t=i；

strcpy(pcb[k].name9pcb1[t].name);

pcb[k].priority=pcbl[t].priority;

pcb[k].runtime=

pcbl[t].runtime;

k=k+l;

for(j=t;j<r;j++)

strcpy(pcbl[j].name,pcbl[j+l].name);

文档仅供参考，不当之处，请联系改正。

pcbl[j].priority=

pcbl[j+l].priority;

pcbl[j].runtime=

pcbl[j+l].runtime;

)

r=r-l;

printf("就绪进程：\nn);

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

printf(n%s%d%d\nn,pcb[j].name,pcb[j].pri

ority,pcb[j].runtime);

printf("堵塞进程：\nn);

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

printf(n%s%d%d\nn,pcbl[j].name,pcbl[j].

priority,pcb1[j].runtime);

break;

)

else

文档仅供参考，不当之处，请联系改正。

printfC该堵塞进程为空，不能唤醒

进程!\暧)；

break;

)

)

//for(j=0;j<k;j++)

//printf(n%s%d%d\nn,pcb[j].name,pcb[j].p

riority,pcb[j].runtime);

if(x==4)

(

printf(n.......................终止进程

....................\nn);

printfC请输入你要终止的进程：

”)；

scanf(n%sn,name);

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

(

if(strcmp(pcb[i].name,name)==O)

(

t=i；

for(j=t;j<k;j++)

文档仅供参考，不当之处，请联系改正。

strcpy(pcb[j].name,pcb[j+l].name);

pcb[j].priority

pcb[j+1].priority;

pcb[j].runtime

pcb[j+1].runtime;

)

k=k-l;

)

if(strcmp(pcbl[i].name,name)==O)

|

t=i；

for(j=t;j<r;j++)

(

strcpy(pcbl[j].name,pcbl[j+l].name);

pcbl[j].priority

pcbl[j+l].priority;

pcbl[j].runtime

pcbl[j+l].runtime;

文档仅供参考，不当之处，请联系改正。

)

r=r-l;

)

)

printf("就绪进程:\nH);

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

printf(n%s%d%d\nn,pcb[j].name,pcb[j].pri

ority,pcb[j].runtime);

printf("堵塞进程：\nH);

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

printf(n%s%d%d\nn,pcbl[j].name,pcbl[j].

priority,pcbl[j].runtime);

)

if(x==5)

(

printf(n...................显示进程

..........S')；

文档仅供参考，不当之处，请联系改正。

printfC就绪进程：\nn);

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

printf(n%s%d%d\nn,pcb[j].name,pcb[j].pri

ority,pcb[j].runtime);

printf("堵塞进程：\nn);

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

printf(n%s%d%d\nM,pcbl[j].name,pcbl[j].

priority,pcbl[j].runtime);

)

)

)

文档仅供参考，不当之处，请联系改正。

程序运行结果及分析

1)运行结果

»*C:\Windows\sy$tem32\Debug'llll.exe*

--------菜单一…一■=

退系

出

0---

-进

进

-建

创

-进

进

-示

-〈

进

显

清输入你的选择：1

-----------------创建迓程一

谭程名，a

优先练2

海行时间：3

耦输入你的选择।La…

卜----------------创建进程一

除程拓b

唯越2

运行时冏3

常输入你的选择，5曰二小知

-----------------显:程一

就绪进程।

A23

b23

堵塞进程।

g23

请输入你的选择：2

-----------------堵塞进程一

清解人要喜找电注程一

醯舞列调度为运行…2

s23

A23

请输入你的选择：3

-----------------映酸进程-

最黔第唤醒的进笛$

b23

s23

堵塞进程：

a23

产

请输入你的选择：4

-----------------终止进程一

曙辞要终止的进道a

b23

s23

实验感想：

经过设计并调试创立、终止、阻塞、唤

醒原语功能,加深了对操作系统中进程控制

功能的理解,而且掌握操作系统模块的设计

方法和工作原理。更重要的是理解了操作系

文档仅供参考，不当之处，请联系改正。

统的调度方法是就绪-运行-堵塞-唤醒-结

束的过程。

文档仅供参考，不当之处，请联系改正。

实验二、模拟进程调度功能

实验目的：

经过本实验，进一步掌握进程调度的功能

和实现原理。

实验内容：

1、设计进程调度功能，至少模拟两种以上调度

算法。如：优先级调度算法、时间片调度算

法等。

2、进程调度功能作为一个函数scheduler,加

入到实验题目一中。

3、进程调度程序从就绪队列中挑选进程，若队

列为空，应显示“无就绪进程无法调度”的

提示信息。

4、若选上一个进程，以显示：进程名、状态、

时间片、优先级等信息表示一个进程被执行。

若运行完，应删除相应PCB。

文档仅供参考，不当之处，请联系改正。

实验步骤:

1、在实验题目一中的主菜单中加入一个菜单

项：6调度，选择该菜单项后，系统进入进

程调度。

2、进程调度的结榔-------------------

进程调度子菜

单

0--------返

回主菜单

1---------优

先级调度

2--------时

间片调度

请选择您需要

的功能选项：

读入选择=》X

文档仅供参考，不当之处，请联系改正。

返回上级菜单

转优先级调度算法转时间片调度算法

实验代码:

#include<stdio.h>

#include<string.h>

voidpriority();

voidtime();

structPCB

charname[4];

intpriority;

intruntime;

)；

structPCBpcb[5];

intq=5;

voidmain()

文档仅供参考，不当之处，请联系改正。

intp,i;

§11X^丫8由[0].1121110「十1”);〃序歹1|队歹!),优先级

由高到低为1,2,3.•…

pcb[0].priority=2;

pcb[O].runtime=3;

strcpy(pcb[1].nameJp2'')序歹[J队歹!J

pcb[l].priority=3;

pcb[l].runtime=2;

§1；0^丫8(:1)[2].1121]10」十3");〃序歹1|队歹1|

pcb[2].priority=1;

pcb[2].runtime=4;

strcpy(pcb[3].nameJp4");〃序歹lj队歹!J

pcb[3].priority=5;

pcb[3].runtime=6;

§(1\^丫8(:夙4].1121]10」十5");〃序歹[]队歹!|

pcb[4].priority=4;

pcb[4].runtime=5;

printf（".........................................进程调度子菜

单...................\nn）;

文档仅供参考，不当之处，请联系改正。

printf（n

0............退出系统\n”）；

printf（n

1.....优先级调度\n”）；

printf（n

2.....时间片调度\n”）；

printf（n\n\ii显示所有进程\n"）;

for（i=0;i<5;i++）

printf(n%s%d%d\nn,pcb[i].name,pcb[i].

priority,pcb[i].runtime);

printf("请选择您需要的功能选项:")；

scanf(n%dn,&p);

printf**********************")•

while(l)

if(p==0)

break;

switch(p)

//case0:

文档仅供参考，不当之处，请联系改正。

//break;

case1:

printf("优先级调度算法\n");

priority();

break;

case2:

printf("时间片调度算法\n“);

time();

break;

)

printf("请选择您需要的功能选项

scanf(n%dn,&p);

printf(，，**********************'')•

)

voidpriorityO

(

inti,j;

intt=O,r=O;

//intq=5;

文档仅供参考，不当之处，请联系改正。

charname[2]=nn;

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

for(j=i;j<q;j++)

(

if(pcb[i].priority>pcb[j].priority)

(

strcpy(name,pcb[i].name);

strcpy(pcb[i].name,pcb[j].name);

strcpy(pcb[j].name,name);

t=pcb[i].priority;

pcb[i].priority=pcb[j].priority;

pcb[j].priority=t;

r=pcb[i].runtime;

pcb[i].runtime=pcb[j].ruiitime;

pcb[j].ruiitime=r;

)

)

printf("按优先级高低进行排序\n”)；

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

文档仅供参考，不当之处，请联系改正。

printf(n%s%d%d\nn,pcb[i].name,pcb[i].

priority,pcb[i].runtime);

printf(，，***********************\u'')•

printf("显示优先级最高的进程\n")；

printf(n%s%d%d\nn,pcb[O].name,pcb[O].p

riority,pcb[0].runtime);

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

strcpy(pcb[i].name,pcb[i+l].name);

pcb[i].priority=pcb[i+l].priority;

pcb[i].runtime=pcb[i+l].runtime;

)

printf(“*********************'')•

printf(“使最高优先级进程处于执行状态

(撤销该进程)\n”)；

for(i=0;ivq-l;i++)〃撤销进程

printf(n%s%d%d\nM,pcb[i].name,pcb[i].

priority,pcb[i].runtime);

q=q-i;

)

文档仅供参考，不当之处，请联系改正。

voidtime()

inti,j,t；

//intq=5;

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

printf(n%s%d%d\nn,pcb[i].name,pcb[i].

priority,pcb[i].runtime);

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

pcb[i].runtime=pcb[i].runtime-l;

)

printf("***********************'n'')•

printf("将每个执行进程的执行时间减去一个

时间片。\n");

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

printf(n%s%d%d\nn,pcb[i].name,pcb[i].

priority,pcb[i].runtime);

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

文档仅供参考，不当之处，请联系改正。

if(pcb[i].runtime<=0)

{t=i;

for(j=t;j<q;j++)

strcpy(pcb[j].name9pcb[j+1].name);

pcb[j].priority

pcb[j+1].priority;

pcb[j].runtime

pcb[j+1].runtime;

)

)

printf("***********************\n'')•

printf("将进行结束的进程撤销。\n")；

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

文档仅供参考，不当之处，请联系改正。

printf(n%s%d%d\nn,pcb[i].name,pcb[i].

priority,pcb[i].runtime);

)

)

文档仅供参考，不当之处，请联系改正。

程序运行结果及分析

・1'C:\Windows\system32\Debug\2222.exe,I。M囱I由

清选择您需要的功能选项：2

23

32

45

将每个执彳边程的执行时间减去T时间片。

pl22

p231

p544

进行结束的进程撤销。

pl22

p23

44

将每个执行进程的执行时间减去一个时间片。

9121

>230

文档仅供参考，不当之处，请联系改正。

实验感想:

经过本实验，我进一步掌握进了程调度的功

能和实现原理。熟练掌握了两种进程调度算法的

应用，相信这对以后进一步学习操作系统、信息

系统的开发都有很大的好处。

实验三：模拟动态分区首次适应分配和回收算法

实验目的：

经过本实验，可加深理解动态分区分配、回

收程序的功能和具体实现，特别是对回收分区的

合并的理解。

实验内容：

1、设计动态分区首次适应分配、回收算法。

2、设计“未分配区说明表”，格式为：

序号始址长度状态

文档仅供参考，不当之处，请联系改正。

160k2001

0

3、设计”已分配区说明表”，格式为：

作业名|始址］长度状态一

0

0

4、设计显示程序，将“未分配区说明表”和

“已分配区说明表”的内容，显示在屏幕上。

初始分配从一个空闲区分配起，回收时要合

并空区。

实验步骤：

1、系统要求分配一个分区时，应输入:作业名、

作业长度。

2、回收一个分区时，应输入：回收的作业名。

回收的分区请注意是否需要进行合并。

实验代码:

#include<STDIO.H>

#include<STDLIB.H>

intMAX_SEGMENT=10;〃最大碎片值

structPartition〃分区表目

文档仅供参考，不当之处，请联系改正。

intPar_Size;〃分区大小

intPar_No;〃分区序号或者名字

intAddr;〃分区地址

intIsUse;〃分区使用情况,0表示空闲，1表

示使用

Partition*pri;〃前向指针

Partition*next;〃后向指针

)；

Partition*Int()〃函数，返回Partition类型指针

{〃初始化空闲分区表

Partition

list=(structPartition*)malloc(sizeof(struct

Partition));//malloc申请动态分配空间

list->next=NULL;

H=list;

if(!list)

(

printfC'n错误，内存初始化分配失败！程序

结束")；

exit(l);

)

文档仅供参考，不当之处，请联系改正。

Hl=(structPartition*)malloc(sizeof(struct

Partition));

printf("请预先输入分区总大小(以KB为单

位)：”)；

scanf(n%dH,&Hl->Par_Size);

Hl->Addr=0;

Hl->ParNo=0;

Hl->IsUse=0;

Hl->pri=H;

Hl->next=NULL;

H->next=Hl;////list—>H1

returnlist;

)

Partition*InitFPQ

(〃初始化已分配分区表

Partition

inti;

FP=(structPartition*)malloc(sizeof(struct

Partition));

FP->next=NULL;

H=FP;

for(i=0;i<10;i++)〃已分配区先暂定分配

文档仅供参考，不当之处，请联系改正。

十个表目

(

F=(structPartition*)malloc(sizeof(struct

Partition));

if(!F)

(

printf(”n错误，内存分配失败！程序结束

”)；

exit(l);

)

F->ParSize=0;

F->Addr=0;

F->ParNo=0;

F->IsUse=0;

F->next=NULL;

H->next=F;

F->pri=H;

H=H->next;

)

returnFP;

)

Partition*New_Process(Partition

文档仅供参考，不当之处，请联系改正。

Partition*FP)

{〃为新的进程分配资源

Partition

intSize,Name,L;

H=list;

Hl=FP->next;

H=H->next;

printf(”请输入新作业的名称和大小(整

数)\暧)；

printf("作业名称:“)；

scanf(n%dn,&Name);

printf("作业大小(整数):")；

scanf(n%dn,&Size);

while(H)

(

if(!H)〃表目已查完，无法分配

(

prmtf(n\n已无空闲分区，本次无法分

配!”)；

returnlist;

)

else{

文档仅供参考，不当之处，请联系改正。

if(H->IsUse==O)//空表目

//if(H->Par_Size>=Size)〃大小满足,

空闲分区大小》要分配的大小

if(H->Par_Size>=Size)〃大小满足,

|

booltemp=false;

if((H->Par_Size-Size)<=MAX_SEGMENT){//

空闲分区大小-要分配的大小v碎片值，会产生碎

片,将整块内存大小分配出去，

Size=H->Par_Size;//分配的大小

为整块内存

temp=true;〃会产生碎片

)

〃其它情况就分配大小为请求大小，

不会产生碎片，

L=H，Addr;〃保存空闲分地址

if(temp){

printf("该次内存分配会产生碎片,

将整块内存大小％(1分配出去![Size);

}else{

printf("该次内存分配不会产生碎

文档仅供参考，不当之处，请联系改正。

片”)；

)

break;

)

)

H=H->next;〃否则，继续往下查找

)

if(H)

(

if(H->Par_Size>Size)〃大小满足，空闲分区

大小》要分配的大小

(

P=(structPartition*)malloc(sizeof(struct

Partition));〃分配新的表目，处理一条数

据，分配一次内存

P->IsUse=l;

P，Addr=L;〃指向空闲分区地址

P->next=H;〃修改指针

H->pri->next=P;

P->pri=H->pri;

H->pri=P;

P->Par_Size=Size;〃分配大小为要请求分

文档仅供参考，不当之处，请联系改正。

配的大小

P->Par_No二Name;〃名称

H->Par_Size-=Size;〃修改空闲分区,H

所指区块大小减Size

H->Addr+=Size;〃H所指区块地址力口Size

}else

(

H->IsUse=l;〃大小相等的，把当前表

项设置空表目

)

while(Hl)

(

if(Hl->IsUse==O)

(

Hl->Par_No=Name;

Hl->ParSize=Size;

Hl->Addr=L;〃保存已分配地址

Hl->IsUse=l;〃在已分配表中设置为已

分配

break;

)

Hl=Hl->next;

文档仅供参考，不当之处，请联系改正。

)

}else

printf(”所申请资源已大过系统所拥有的,

请重新输入!\n")；

returnlist;

)

Partition*Reclaim(PartitionPartition

*FP)

(〃结束作业，资源回收,N。为作业名，回收内

存

Partition*H1,*H2,*H3,*HF;//H1为释放

区，H2为后分区，H3为前分区

intNo;〃作业名

Hl=list;

HF=FP;〃可有可无？

Hl=Hl->next;

HF=FP->next;

printf("请输入您想结束的作业名:")；

scanf(H%Dn,&No);

while(HF)〃对已分配表进行操作

if(HF->Par_No==No)

文档仅供参考，不当之处，请联系改正。

HF->IsUse=O;〃标志为空表目

break;〃这时保存着HF所指分区的信息

)

HF=HF->next;

)

if(!HF)〃如果找不到该作业，则提示出错

prin情(”所输入的作业名称不正确,请重新

输入!”)；

else{

while(Hl)//对空闲表进行操作

(

if(Hl->Par_No==No)

(

Hl->IsUse=O;〃标志为空表目

printf(”内存回收成功”);

break;

)

Hl=Hl->next;

)

H2=HL>next;〃后分区

H3=HL>pri;〃前分区

文档仅供参考，不当之处，请联系改正。

if(H2&&H2，IsUse==0)〃后接分区为空闲

(

if(H2->next==NULL)〃判断后接分区

是否为尾结点

(

Hl->Par_Size+=H2->Par_Size;//把

H2合并到H1

Hl->next=NULL;

free(H2);

printf(n已回收％d大小内存

n,Hl->Par_Size);

}else〃后分区不为空闲，表示已经被使用

(

Hl->Par_Size+=H2->Par_Size;

Hl->next=H2->next;

H2->next->pri=Hl;

free(H2);

printf(n已回收％d大小内存

n,Hl->Par_Size);

)

)

文档仅供参考，不当之处，请联系改正。

if(H3&&H3->IsUse==0)〃前分区为空闲

分区，则合并去前分区

H3->ParSize+=Hl->ParSize;

H3->next=Hl->next;

if(Hl->next!=NULL)〃若Hl为尾结点

Hl->next->pri=H3;

free(Hl);

printf(n已回收％d大小内存

M,Hl->Par_Size);

)

)

returnlist;

)

voidPrint(PartitionPartition*FP)

(〃输出已分配分区和空闲分区

Partition

Hl=list->next;

H2=FP;

H2=H2->next;

•/

-MVW-%**rjwrj*rj、rj、rj»rjwrjwrj»rjwrjwrjwrj»*jwrjwrjwrjwrjwrj*rj»*J»rj**Jwrj*

*******¥****¥***¥¥g)；

文档仅供参考，不当之处，请联系改正。

•Ar/tf%S»alx*1**2><S«

VJ»*|VITTI5不不不不不不不不不不不不不不不不

printfC分区序号大小开始地址状态

W”)；

while(Hl)

(

printf(n%d%d

%dn,Hl->Par_No,Hl->Par_Size,Hl->Addr);

if(Hl->IsUse==l)

printf(n已分配\n”)；

printf(H空表目\n");

Hl=Hl->next;

ff*£**1*<*«***

*,*]**J«»2*rj«*2«r2*rjwrj»rj*rj«rjw*{«rjwrjwrj*rj*rjwrj»

¥豕***¥¥¥**¥¥¥***¥¥3)；

voidMain_Print(Partition*list,Partition*FP)

〃主入口函数，进行菜单选择

intop;

while(l)

文档仅供参考，不当之处，请联系改正。

printf(n\n........................................主菜单

.................M)；

printf(H\nH);

printf(”L申请新的作业，分配内存\n")；

printf("2.结束作业，回收内存\n”);

printf("3.查看内存表\n");

printf("4.退出系统\n");

printf(n\n请选择vl-4>:");

scanf(n%dn,&op);

switch(op)〃根据输入，选择分支方向

(

case1:

New_Process(list,FP);

break;

case2:

Reclaim(list,FP);

break;

case3:

Print(list,FP);

break;

case4:

break;

文档仅供参考，不当之处，请联系改正。

default:

printf(n\n选择错误，请重新选择!”);

break;

)

if(op==4)

break;〃退出循环

)

)

voidmain()

{〃主函数入口

structPartition*list,*FP;

list=Int();

FP=InitFP();

Main_Print(list,FP);

)

程序运行结果及分析

文档仅供参考，不当之处，请联系改正。

请预先输入分区m大小＜以而为单位〉।120

-----------------------转单一

清诲择

磬入烈f业的名称和大小遭数〉

北坐大片整数＞：80

该茨内在耀冬会产生碎片

•主菜单，

申

益

内存

S第

表

出

的俏

花

业

表

星

出

请选择＜1-4）：2

i束的作业名

卤存回物

四单---------

内存

申

作

出

表

出

运择

解入拓作业的名称和大小《整数〉

业名称：100

黯禽鬻皆累统所拥有的.请重新输入，

-------------------------主菜单--------

申

的伍窗

内存

b整

w^亚

萋

i表

退

出g

二

i*TIM工-

噫

料

表

己C

J硼-

始

口

」

大F

丁

e空

80已

4080

内存

申

的

作窗I

^n掂

董,

录

一

退g

实验感想：

经过本实验，加深了对动态分区分配、

回收程序的功能和具体实现，特别是对回收

文档仅供参考，不当之处，请联系改正。

分区的合并的理解。

实验五：模拟使用银行家算法判断系统的状态

实验目的：

了解进程管理的实现方法，理解和掌握

处理进程同步问题的方法。

实验内容：

实现银行家算法、进程调度过程的模拟、读者-写者问题的写者优先算

法。

实验步骤：

•理解安全性算法和银行家算法的核心机

制：

•理解进程的三状态调度过程，及各状态间的转换关系；

•设计读者-写者问题的写者优先算法；

实验代码：

#include<stdio.h>

#include<stdlib.h>

#include<conio.h>

文档仅供参考，不当之处，请联系改正。

#definem50

intnol;〃进程数

intno2;〃资源数

intr;

int

allocation[m][m],need[m][m],available[m],max[

charnamel[m],name2[m];

〃定义全局变量

voidmain()

voidcheck();

voidprint();

inti,j,p=O,q=O;

charc;

int

request[m],allocationl[m][m],needl[m][m],avail

ablel[m];

printf(n银行家算法

\n"）；

文档仅供参考，不当之处，请联系改正。

printf「请输入进程总数

scanf(n%dn,&nol);

printfC请输入资源种类数严)；

scanf(M%dM,&no2);

printf("请输入最大需求矩阵八n")；

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

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

scanf(n%dn,&max[i][j]);〃输入已知

进程最大资源需求量

printf(”请输入当前分配矩阵:\n")；

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

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

scanf(n%dn,&allocation[i][j]);〃输入

已知的进程已分配的资源数

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

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

need[i][j]=max[i][j]-allocation[i]|j];//根

据输入的两个数组计算出need矩阵的值

printf（"请输入可利用资源矩阵\n"）;

文档仅供参考，不当之处，请联系改正。

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

scanf(H%dH,&available[i]);〃输入

已知的可用资源数

printQ;〃输出已知条件

check();〃检测TO时刻已知条件的安全状态

if(r==l)〃如果安全则执行以下代码

(

do{

q=0；

P=0；

printf("\n请输入请求资源的进程号

(0-4)：\nn);

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

(

scanf(n%dn,&i);

if(i>=nol)

|

printf("输入错误,请重新输入:\n");

continue;

)

文档仅供参考，不当之处，请联系改正。

elsebreak;

)

printf("\n请输入该进程所请求的资源数

request[j]:\nn);

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

scanf(n%dn,&request[j]);

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

if(request[j]>need[i][j])p=l;

〃判断请求是否超过该进程所需要的

资源数

if(p)

printf("请求资源超过该进程资源需

求量，请求失败！\nn);

else

(

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

if(request[j]>available[j])q=l;〃判

断请求是否超过可用资源数

if(q)

printf(“没有做够的资源分配，请

求失败！\nn);

文档仅供参考，不当之处，请联系改正。

else

〃请求满足条件

(

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

(

availablel[j]=available[j];

allocation1[i][j]=allocatioii[i][j];

needl[i][j]=need[i][j];

〃保存原已分配的资源数，仍需要的

资源数和可用的资源数

available[j]=available[j]-request[j];

allocation[i][j]+=request[j];

need[i][j]=need[i][j]-request[j];

〃系统尝试把资

源分配给请求的进程

)

print。；

check();〃检测分配后的安

全性

文档仅供参考，不当之处，请联系改正。

if(r==O)〃如果分配后系统不安

全

(

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

(

available[j]=availablel[j];

allocation[i][j]=allocatioiil[i][j];

need[i][j]=needl[i][j];

〃还原已分配的资源数，

仍需要的资源数和可用的资源数

)

print—返回分配前资源数

W)；

print();

)

)

}prmtf(n\n你还要继续分配吗？Yor

N?\nn);

〃判断是否继续进行资源分配

c=getche();

}while(c==,y,||c==,Y*);

文档仅供参考，不当之处，请联系改正。

)

)

voidcheck()〃安全算法函数

(

intk,f,v=O,i,j；

intwork[m],a[m];

boolfinish[m];

r=l;

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

finish[i]=false;〃初始化进程均没得到

足够资源数并完成

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

work[i]=available[i];〃work[i]表示可提供

进程继续运行的各类资源数

k=nol;

do{

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

if(finish[i]==false)

文档仅供参考，不当之处，请联系改正。

f=l;

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

if(need[i][j]>work[j])

f=0;

if(f==l)〃找到还没有完成且

需求数小于可提供进程继续运行的资源数的进

程

(

finish[i]=true;

a[v++]=i;〃记录安全序列号

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

work[j]+=allocatioii[i][j];〃释

放该进程已分配的资源

)

)

)

k-;〃每完成一个进程分配，未完成

的进程数就减1

}whiIe(k>0);

f=l；

for(i=0;i<nol;i++)〃判断是否所有的进程

都完成

文档仅供参考，不当之处，请联系改正。

if(finish[i]==false)

(

f=0;

break;

)

)

if(f==O)〃若有进程没完成，则为不安

全状态

(

printf("系统处在不安全状态！”)；

r=0;

)

else

(

printf(n\n系统当前为安全状态，安全序列

为:\nn);

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

printf(Mp%dn,a[i]);〃输出安全序列

)

)

文档仅供参考，不当之处，请联系改正。

voidprint()〃输出函数

inti,j;

printf(n\nn);

printf(**************此时刻资源分配情况

¥¥***¥¥¥**¥¥¥***¥¥¥**W•fX).

printfc进程名/号|最大需求矩阵|

当前分配矩阵I需求矩阵|\暧)；

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

(

printf(Mp%d/%dn,i,i)；

forG=0;j<no2;j++)

{printf(n%dn,max[i][j]);}

for0=0;j<no2;j++)

{printf(H%d

n,a