操作系统实验五Word格式.docx

操作系统实验五Word格式.docx

《操作系统实验五Word格式.docx》由会员分享，可在线阅读，更多相关《操作系统实验五Word格式.docx（15页珍藏版）》请在冰豆网上搜索。

5、流程图

六、程序代码

1、优先数调度

#include"

stdio.h"

stdlib.h"

#include"

string.h"

#include<

windows.h>

conio.h>

#defineWAIT1

#defineRUN2

#defineFINISH3

typedefstructpcb

{

charnum;

structpcb*next;

intpriority;

inttimeneed;

intstate;

}pcb;

/*用此结构体来模拟一个进程*/

structpcb*head;

structpcb*run;

pcb*jccreat（intn）/*此函数用于创建进程队列*/

inti=1;

pcb*head,*p,*q;

head=（pcb*）malloc（sizeof（pcb））;

/*创建一个空表头*/

p=head;

for（i=1;

i<

=n;

i++）/*用循环来创建指定个结点*/

{

fflush（stdin）;

//添加

q=（pcb*）malloc（sizeof（pcb））;

p->

next=q;

printf（"

Inputnum,priority,timeneed:

"

）;

scanf（"

%c,%d,%d"

&

q->

num,&

priority,&

timeneed）;

q->

state=WAIT;

next=NULL;

p=q;

}

returnhead;

/*返回表头指针*/

}

pcb*getmaxpriority（structpcb*head）/*此函数用来挑选一个优先级最大的进程来执行*/

structpcb*p,*q;

intmax;

p=head->

next;

max=p->

priority;

/*初始max为队首结点的优先级*/

q=p;

while（p）

if（p->

priority>

max）/*逐一比较，选出优先级最大的结点*/

max=p->

q=p;

}

p=p->

returnq;

voiddelect（structpcb*head,structpcb*run）/*此函数用来将运行完的进程删除出进程队列*/

structpcb*q=head;

while（q->

next）/*扫描进程队列，找到执行完了的进程*/

if（q->

next->

num==run->

num）/*判断是不是已完成的进程*/

if（run->

next!

=NULL）

next=run->

elseq->

free（run）;

/*释放申请的空间*/

return;

q=q->

voidcontrol（）/*此函数是用来控制各个进程的执行和调度*/

structpcb*p;

run=head->

/*初始让第一个进程运行*/

run->

state=RUN;

while（run）

timeneed>

0）/*如果当前run指针指向的进程所需时间不为零，状态为运行状态，就让这个进程运行*/

state==RUN）

printf（"

pcb%cisrunning.\n"

run->

num）;

Waitinglist:

\n"

/*显示整个等待队列*/

NUMPRIORITYTIMENEEDSTATE\n"

if（p!

=run）

%c%d%d%d\n"

p->

num,p->

priority,p->

timeneed,p->

state）;

//delay（10000000）;

/*模拟进程运行*/

//sleep（100）;

for（inti=0;

1000000;

i++）{}

timeneed--;

/*进程需要时间减一*/

priority=run->

priority-3;

/*进程优先级减三*/

timeneed!

=0）

priority<

=getmaxpriority（head）->

priority）/*如果当前运行完的进程的优先级低于队列中优先级最高的进程*/

{run->

run=getmaxpriority（head）;

/*从进程队列中挑选一个优先级最大的进程来运行*/

else

{printf（"

pcb%cisfinished.\n"

delect（head,run）;

/*删除该结点*/

if（head->

=NULL）/*判断进程队列是不是为空*/

{run=head->

else

{printf（"

Allprogressesaredone.\n"

}

voidmain（）

intn;

intflag=1;

Enterthenumberoftheprogresses:

%d"

n）;

/*输入要创建的进程的数量*/

head=jccreat（n）;

/*创建进程队列，将链表的表头赋给head指针*/

/*run指针指向正在运行的进程的pcb*/

********显示系统中所有进程PCB********\n"

printf（"

num,run->

priority,run->

timeneed,run->

run=run->

}/*将刚创建的进程队列打印出来*/

while（flag）/*由flag的值判断是否继续执行control（）函数*/

if（head->

next）/*判断进程是否完成*/

control（）;

elseflag=0;

getch（）;

2、先来先服务

#include<

stdio.h>

string.h>

//使用time（）函数

#defineDELAY100//时间延迟

#defineSJP4

/**********全局变量声明**********/

unsignedshortTIME=0;

//时间

unsignedshortNUM=0;

//进程数量

//PCB结构体定义

typedefstructPCB

charname[16];

charstate;

//[R]Run,[F]Finish,[P]Pause,[N]New

unsignedshortpriority;

//数字越大，优先级越高，最小为1

unsignedshortt_arrive;

//到达时间

unsignedshortt_start;

//开始时间

unsignedshortt_finish;

//完成时间

unsignedshortt_service;

//服务时间

unsignedshortt_run;

//运行时间

unsignedshortt_wait;

//等待时间

structPCB*next;

}pcb;

pcb*now=NULL,//现在运行的pcb

*head=NULL;

//pcb链头部指针

/**********函数声明**********/

voidfcfs（）;

//先到先服务

voidinit（）;

//初始化完成pcb录入

pcb*sort（pcb*）;

//对init（）录入的pcb安到达时间排序

voidtimer（）;

//定时器，每一个延迟自我调用一次

voidresult（）;

//打印结果

//先来先服务调度算法

voidfcfs（）

if（now->

t_arrive>

TIME）

[时间：

%d]\t无进程运行\n"

TIME）;

state=='

N'

）

now->

state='

R'

;

t_start=TIME;

%d]\t进程：

%s首次运行\n"

TIME,now->

name）;

elseif（now->

（now->

t_run）++;

t_run>

=now->

t_service）

F'

t_finish=TIME;

%s任务完成\n"

now=now->

if（now!

=NULL）fcfs（）;

elseprintf（"

%s正在运行，已运行时间：

%d\n"

name,now->

t_run）;

voidresult（）

pcb*p=head;

\n=========运行结果=========\n\n"

名称优先级到达时间开始时间完成时间服务时间周转时间带权周转时间\n"

while（p!

%s\t%d\t%d\t%d\t%d\t%d\t%d\t%.2f\n"

name,p->

t_arrive,

t_start,p->

t_finish,p->

t_service,p->

t_finish-p->

1.0*（p->

t_arrive）/p->

t_service）;

voidtimer（）

fcfs（）;

if（now==NULL）return;

TIME++;

Sleep（DELAY）;

timer（）;

voidinit（）

pcb*p,*q;

unsignedshorti;

输入进程数目:

NUM）;

for（i=0;

i<

NUM;

i++）

p=（pcb*）malloc（sizeof（pcb））;

[第%d个]一次输入：

名称优先度到达时间服务时间\n"

i+1）;

%s\t%d\t%d\t%d"

p->

name,&

t_arrive,&

if（head==NULL）

head=p;

next=p;

t_start=0;

t_finish=0;

t_run=0;

t_wait=0;

//按到达时间冒泡排序

pcb*sort_pcb（pcb*h_head）

pcb*p,*p1,*p2,*p3;

pcbh,t;

if（h_head==NULL）returnNULL;

h.next=h_head;

p=&

h;

while（p->

next=&

t;

while（p!

=h.next）

p3=&

p1=p3->

p2=p1->

while（p2!

=p）

if（（p1->

t_arrive）>

（p2->

t_arrive））

p1->

next=p2->

p2->

next=p1;

p3->

next=p2;

p3=p2;

p3=p1;

p1=p2;

p2=p2->

p=p1;

=&

t）

returnh.next;

voidmain（）

init（）;

system（"

CLS"

head=sort_pcb（head）;

now=head;

进程正在模拟运行\n"

result（）;

七、结果显示

八、实验总结

通过这次的模拟实验，对进程控制有了更进一步的了解，对它的运行机制更加清楚了，总的来说收获还是很多的。