操作系统实验一进程创建删除调度等实验报告.docx

操作系统实验一进程创建删除调度等实验报告.docx

《操作系统实验一进程创建删除调度等实验报告.docx》由会员分享，可在线阅读，更多相关《操作系统实验一进程创建删除调度等实验报告.docx（30页珍藏版）》请在冰豆网上搜索。

操作系统实验一进程创建删除调度等实验报告

实验一实验报告

实验源码：

#include"stdio.h"

#include

#include

#include

#include

#include

//内存最大装备作业数

#defineN5

#defineP_TIME50

structPCB{

intpid;//进程id

intpriority;//优先权

intsize;//大小

intstate;//进程状态0表示不存在1表示运行状态2表示阻塞状态

charinfo[10];//消息

};

structPCBneicun[N];

intshumu=0,guaqi=0;

intpid;

intflag=0;//查找相应进程是否存在的标志

//进程调度

enumstate{

ready,

working,

block,

finish

};//定义进程状态

structD_PCB{

charname[4];//进程名

intpriority;//优先权

intcputime;//CPU运行时间

intneedtime;//进程运行所需时间

intcount;//进程执行次数

intround;//时间片轮转轮次

stateprocess;//进程状态

D_PCB*next;

};//定义进程PCB

//创建进程

voidcreate（）

{

system（"cls"）;

if（shumu>=N）printf（"\n内存已满，请先换出或杀死进程\n"）;

else{

for（inti=0;i

//定位，找到还未创建的进程

if（neicun[i].state==0）break;

printf（"请输入新进程pid\n"）;

scanf（"%d",&（neicun[i].pid））;

for（intj=0;j

if（neicun[j].pid==neicun[i].pid）{

printf（"\n该进程已存在\n"）;

return;

}

printf（"请输入新进程优先级\n"）;

scanf（"%d",&（neicun[i].priority））;

printf（"请输入新进程大小\n"）;

scanf（"%d",&（neicun[i].size））;

printf（"请输入新进程内容\n"）;

scanf（"%s",&（neicun[i].info））;

//创建进程，使标记位为1

neicun[i].state=1;

shumu++;

}

}

//查看运行进程

voidrun（）

{

system（"cls"）;

printf（"\npid\tprioroty\tsize\tstate\tinfo\n"）;

for（inti=0;i

if（neicun[i].state==1）{

//输出运行进程的各个属性值

printf（"%d\t%d\t\t%d\t%d\t%s\n",neicun[i].pid,neicun[i].priority,neicun[i].size,neicun[i].state,neicun[i].info）;

flag=1;

}

}

if（!

flag）printf（"\n当前没有运行进程\n"）;

}

//换出进程

voidhuanchu（）

{

system（"cls"）;

if（!

shumu）{

printf（"当前没有运行进程\n"）;

return;

}

printf（"\n输入换出运行进程ID值\n"）;

scanf（"%d",&pid）;

for（inti=0;i

//定位，找到所要换出的进程，根据其状态做相应处理

if（pid==neicun[i].pid）{

if（neicun[i].state==1）{

neicun[i].state=2;

guaqi++;

printf（"\n已经成功换出进程\n"）;

}

elseif（neicun[i].state==0）printf（"\n要换出的进程不存在\n"）;

elseprintf（"\n换出的进程已被挂起\n"）;

flag=1;

break;

}

}

//找不到，则说明不存在

if（flag==0）printf（"\n要换出的进程不存在\n"）;

}

//杀死进程

voidkill（）

{

system（"cls"）;

if（!

shumu）{

printf（"当前没有运行进程\n"）;

return;

}

printf（"\n输入杀死进的的ID值\n"）;

scanf（"%d",&pid）;

for（inti=0;i

//定位，找到所要杀死的进程，根据其状态做相应处理

if（pid==neicun[i].pid）{

if（neicun[i].state==1）{

neicun[i].state=0;

shumu--;

printf（"\n已成功杀死进程\n"）;

}

elseif（neicun[i].state==0）printf（"\n要杀死的进程不存在\n"）;

elseprintf（"\n要杀死的进程已被挂起\n"）;

flag=1;

break;

}

}

//找不到，则说明进程不存在

if（!

flag）printf（"\n要杀死的进程不存在\n"）;

}

//唤醒进程

voidhuanxing（）

{

system（"cls"）;

if（!

shumu）{

printf（"当前没有运行进程\n"）;

return;

}

if（!

guaqi）{

printf（"\n当前没有挂起进程\n"）;

return;

}

printf（"\n输入pid：

\n"）;

scanf（"%d",&pid）;

for（inti=0;i

//定位，找到所要杀死的进程，根据其状态做相应处理

if（pid==neicun[i].pid）{

flag=0;

if（neicun[i].state=2）{

neicun[i].state=1;

guaqi--;

printf（"\n已经成功唤醒进程\n"）;

}elseif（neicun[i].state==0）

printf（"\n要唤醒的进程不存在\n"）;

break;

}

}

//找不到，则说明进程不存在

if（flag）printf（"\n要唤醒的进程不存在\n"）;

}

//进程通信

voidtongxin（）

{

system（"cls"）;

intps,pr;

printf（"Pleaseentersender'spid:

\n"）;

scanf（"%d",&ps）;

printf（"Pleaseenterreceiver'spid:

\n"）;

scanf（"%d",&pr）;

for（inti=0;i

{

for（intj=0;j

{

if（（neicun[i].pid==ps）&&（neicun[j].pid==pr））

strcpy（neicun[j].info,neicun[i].info）;

}

}

}

//进程调度

//优先权调度算法

//输入模拟测试的进程名和执行所需时间，初始设置可模拟5个进程的调度

D_PCB*get_process（）{

D_PCB*q;

D_PCB*t;

D_PCB*p;

inti=0;

intP_NUM;

printf（"inputnumber:

"）;

scanf（"%d",&P_NUM）;

printf（"inputnameandtime\n"）;

while（i

q=（structD_PCB*）malloc（sizeof（D_PCB））;

scanf（"%s",&（q->name））;

scanf（"%d",&（q->needtime））;

q->cputime=0;

q->priority=P_TIME-q->needtime;

q->process=ready;

q->next=NULL;

if（i==0）{

p=q;

t=q;

}else{

t->next=q;//创建就绪进程队列

t=q;

}

i++;

}//endwhile

returnp;

}

//显示模拟结果，包含进程名、CPU时间、运行所需时间以及优先级

voiddisplay（D_PCB*p）{

printf（"name\tcputime\tneedtime\tprioruty\tstate\n"）;

while（p）{

printf（"%s\t%d\t%d\t\t%d\t\t",p->name,p->cputime,p->needtime,p->priority）;

switch（p->process）{

caseready:

printf（"ready\n"）;

break;

caseworking:

printf（"working\n"）;

break;

caseblock:

printf（"block\n"）;

break;

casefinish:

printf（"finish\n"）;

break;

}

p=p->next;

}

}

//结束进程，即将队列中各进程所需时间设置为0

intprocess_finish（D_PCB*q）{

intbl=1;

while（bl&&q）{

bl=bl&&q->needtime==0;

q=q->next;

}

returnbl;

}

//选择某一进程，给它分配CPU

voidcpuexe（D_PCB*q）{

D_PCB*t=q;

inttp=0;

while（q）{

if（q->process!

=finish）{

q->process=ready;

if（q->needtime==0）{

q->process=finish;

}

}

if（tppriority&&q->process!

=finish）{

tp=q->priority;

t=q;

}

q=q->next;

}

if（t->needtime!

=0）{

t->priority-=3;

t->needtime--;

t->process=working;

t->cputime++;

}

}

//计算进程优先级

voidpriority_cal（）{

D_PCB*p;

system（"cls"）;

p=get_process（）;

intcpu=0;

system（"cls"）;

while（!

process_finish（p））{

cpu++;

printf（"cputime:

%d\n",cpu）;

cpuexe（p）;

display（p）;

Sleep

（2）;

}

printf（"Allprocesseshavefinished!

\n"）;

}

//显示调度算法菜单，可供用户选择优先权调度算法和时间片轮转算法

voiddisplay_menu（）{

system（"cls"）;

printf（"*******************************\n"）;

printf（"CHOOSETHEALGORITHM:

\n"）;

printf（"1PRIORITY\n"）;//优先权调度算法

printf（"2ROUNDROBIN\n"）;//时间片轮转算法

printf（"3EXIT\n"）;

printf（"*******************************\n"）;

}

//时间片轮转算法

//时间片轮转调度算法创建就绪进程队列

D_PCB*get_process_round（）{

D_PCB*q;

D_PCB*t;

D_PCB*p;

inti=0;

intP_NUM;

printf（"inputnumber:

"）;

scanf（"%d",&P_NUM）;

printf（"inputnameandtime\n"）;

while（i

q=（structD_PCB*）malloc（sizeof（D_PCB））;

scanf（"%s",&（q->name））;

scanf（"%d",&（q->needtime））;

q->cputime=0;

q->round=0;

q->count=0;

q->process=ready;

q->next=NULL;

if（i==0）{

p=q;

t=q;

}else{

t->next=q;

t=q;

}

i++;

}//endwhile

returnp;

}

//采用时间片轮转算法执行某一进程

voidcpu_round（D_PCB*q）{

q->cputime+=2;

q->needtime-=2;

if（q->needtime<0）{

q->needtime=0;

}

q->count++;

q->round++;

q->process=working;

}

//获取下一个进程

D_PCB*get_next（D_PCB*k,D_PCB*head）{

D_PCB*t;

t=k;

do{

t=t->next;

}while（t&&t->process==finish）;

if（t==NULL）{

t=head;

while（t->next!

=k&&t->process==finish）{

t=t->next;

}

}

returnt;

}

//设置队列中进程执行状态

voidset_state（D_PCB*p）{

while（p）{

if（p->needtime==0）{

p->process=finish;//如果所需执行时间为0，则设置运行状态为结束

}

if（p->process==working）{

p->process=ready;//如果所需执行状态则设置为就绪

}

p=p->next;

}

}

//时间片轮转调度算法输出调度信息

voiddisplay_round（D_PCB*p）{

printf（"NAME\tCPUTIME\tNEEDTIME\tCOUNT\tROUND\tSTATE\n"）;

while（p）{

printf（"%s\t%d\t%d\t\t%d\t%d\t",p->name,p->cputime,p->needtime,p->count,p->round）;

switch（p->process）{

caseready:

printf（"ready\n"）;

break;

caseworking:

printf（"working\n"）;

break;

caseblock:

printf（"block\n"）;

break;

casefinish:

printf（"finish\n"）;

break;

}

p=p->next;

}

}

//时间片轮转调度算法计算轮次及输出调度信息

voidround_cal（）{

D_PCB*p;

D_PCB*r;

system（"cls"）;

p=get_process_round（）;

intcpu=0;

system（"cls"）;

r=p;

while（!

process_finish（p））{

cpu+=2;

cpu_round（r）;

r=get_next（r,p）;

printf（"cpu:

%d\n",cpu）;

display_round（p）;

set_state（p）;

Sleep

（2）;

}

}

voidreturn_menu（）;

//是否返回主菜单

voidis_return_menu（）

{

printf（"returntoformermenu?

（YorNtoMainMenu）\n"）;

chark;

k=getch（）;

switch（k）{

case'Y':

return_menu（）;

break;

case'N':

break;

case'y':

return_menu（）;

break;

case'n':

break;

default:

is_return_menu（）;

break;

}

}

//返回主菜单

voidreturn_menu（）

{

display_menu（）;

intk;

scanf（"%d",&k）;

switch（k）{

case1:

priority_cal（）;

is_return_menu（）;

break;

case2:

round_cal（）;

is_return_menu（）;

break;

case3:

break;

}

}

intmain（intargc,char*argv[]）

{

intn=1;

intnum;

//初始化所有未被创建进程的状态，一开始所有进程都不在内存中

for（inti=0;i

neicun[i].state=0;

while（n）{

printf（"\n**************************************************"）;

printf（"\n*进程演示系统*"）;

printf（"\n**************************************************"）;

printf（"\n1.创建新的进程2.查看运行进程"）;

printf（"\n3.换出某个进程4.杀死运行进程"）;

printf（"\n5.唤醒某个进程6.进程之间通信"）;

printf（"\n7.进程调度8.退出系统"）;

printf（"\n**************************************************"）;

printf（"\n请选择（1~8）\n"）;

scanf（"%d",&num）;

switch（num）{

case1:

create（）;break;

case2:

run（）;break;

case3:

huanchu（）;break;

case4:

kill（）;break;

case5:

huanxing（）;break;

case6:

tongxin（）;

break;

case7:

return_menu（）;

break;

case8:

exit（0）;break;

default:

n=0;

}

flag=0;//恢复标记

}

return0;

}

实验结果截图：

主界面：

创建一个新的进程：

查看进程：

再创建两个新的进程并查看：

换出进程号为1的进程并查看：

杀死一个进程号为3的进程并查看：

唤醒刚刚被挂起的进程号为1的进程并查看：

进程号为1的进程和进程号为2的进程之间通信并查看：

进程调度：

优先权算法：

输入有几个进程：

输入5个进程名及其优先权运行时间：

时间片轮转算法：

输入有几个进程：

输入5个进程名及其优先权运行时间：