进程调度C语言实现Word文档格式.docx
《进程调度C语言实现Word文档格式.docx》由会员分享，可在线阅读，更多相关《进程调度C语言实现Word文档格式.docx（20页珍藏版）》请在冰豆网上搜索。
}ProcessNode,*Linklist;
voidmain（）
{
intchoice;
;
.
Linklistp,head;
Linklistread_information（）;
LinklistFCFS_scheduling（Linklisthead）;
LinklistSJF_scheduling（Linklisthead）;
LinklistRR_scheduling（Linklisthead）;
LinklistPri_scheduling（Linklisthead）;
head=read_information（）;
//读入进程的基本信息
do{
p=head->
next;
printf（\
）;
**********\n）;
//输出初始化后的进程基本信息printf（**********进程初始信息输出printf（\
牰湩晴尨进程名称牰湩晴尨到达时间）;
牰湩晴尨服务时间）;
牰湩晴尨优先级）;
while（p）
printf（%c,p->
name）;
p->
arrive_time）;
%dprintf（
printf（%d,p->
service_time）;
priority）;
p=p->
}
printf（\
printf（************************************\n）;
//输出进程的调用选择项
\n）;
、printf（FCFS----先到先服务
短作业优先、SJF-----printf（
RR------时间片轮转printf（、
Pri-----printf（、优先权调度printf（_x0005_、退出\n）;
printf（************************************\n）;
5—1牰湩晴尨请在之间选择:
scanf（%d,&
choice）;
switch（choice）
{
case1:
FCFS_scheduling（head）;
break;
case2:
SJF_scheduling（head）;
break;
case3:
RR_scheduling（head）;
Pri_scheduling（head）;
case4:
exit（）;
//case5:
}
}while（choice!
=5）;
Linklistread_information（）//进程读入函数{
inti;
num;
int
//ProcessNode;
Linklistpro;
Linklistp;
Linklisthead;
printf（************进程调度算法************\n）;
牰湩晴尨请输入进程的个数:
scanf（%d,&
num）;
*************\n）;
初始化信息printf（*************printf（\
head=（Linklist）malloc（sizeof（ProcessNode））;
//头结点
head->
next=NULL;
p=head;
for（i=1;
i<
=num;
i++）
pro=（Linklist）malloc（sizeof（ProcessNode））;
//创建进程结点
:
\n,i）;
输入第printf（%d个进程信息;
printf（请输入进程名:
）;
fflush（stdin）;
scanf（%c,&
pro->
printf（到达时间:
printf（服务时间:
优先级↑printf（
//pro->
next=head->
head->
next=pro;
//逆序建链
p->
p=pro;
//顺序建链
//p++;
returnhead;
先到先服务算法函数LinklistFCFS_scheduling（Linklisthead）//{
Linklistq;
//指向前一进程
while（p）//初始化进程的完成时间、周转时间、带权周转时间，初值均赋为0
FCFS_time.finish_time=0;
FCFS_time.turnaround_time=0;
FCFS_time.weigtharound_time=0;
p=q=head->
0避免第一个进程到达时间不为p->
FCFS_time.finish_time=p->
arrive_time;
//
while（p）
{
if（p->
arrive_time<
=q->
FCFS_time.finish_time）//下一进程已到达，在等待中{
FCFS_time.finish_time=（p->
service_time）+（q->
FCFS_time.finish_time）;
//服务时间;
FCFS_time.turnaround_time=（p->
FCFS_time.finish_time）-（p->
//周转时间
FCFS_time.weigtharound_time=（float）（p->
FCFS_time.turnaround_time）/（p->
//带权周转时间
}
else
{
service_time+p->
//服务时间
带p->
//权周转时间
}
q=p;
p=p->
p=head->
输出先\n）;
//FCFS********************************printf（********************************
到先服务调度后的进程信息printf（\
牰湩晴尨进程名称
牰湩晴尨到达时间）;
牰湩晴尨完成时间）;
牰湩晴尨周转时间）;
牰湩晴尨带权周转时间）;
printf（%d,p->
printf（%d,p->
FCFS_time.turnaround_time）;
printf（%0.2f,p->
FCFS_time.weigtharound_time）;
printf（**********************************************************************\n）;
returnhead;
LinklistSJF_scheduling（Linklisthead）//短作业优先算法
Linklistp,r;
Linklistq;
//指向前一进程结点
intnum=0;
//记录进程个数
intadd_flag=0;
//进程完成服务个数
intservice_time_min;
intk;
//首元结点
0while（p）//初始化进程的完成时间、周转时间、带权周转时间，初值均赋为
p->
SJF_time.finish_time=0;
SJF_time.turnaround_time=0;
SJF_time.weigtharound_time=0;
SJF_time.flag=0;
++num;
q->
//将创建的进程队列变为循环队列
SJF_time.finish_time=p->
arrive_time+p->
service_time;
SJF_time.turnaround_time=（p->
SJF_time.finish_time）-（p->
SJF_time.weigtharound_time=（float）（p->
SJF_time.turnaround_time）/（p->
SJF_time.finish_time;
add_flag=1;
SJF_time.flag=1;
SJF_time.flag==1）{p=p->
elseif（（p->
arrive_time）>
（q->
SJF_time.finish_time））
service_time_min=p->
arrive_time=p->
while（p->
arrive_time==arrive_time&
&
SJF_time.flag==0）//寻找最短的作业{
if（（p->
next->
service_time）<
（p->
service_time））{service_time_min=p->
else{p=p->
p=q->
r=q;
service_time!
=service_time_min）{p=p->
}//指针指向最短作业
++add_flag;
//周转时间
带权周转时间p->
//q=p;
p=r->
k=0;
while（（（p->
arrive_time）<
=（q->
SJF_time.finish_time））&
k<
=num）//寻找最短的作业{
if（p->
SJF_time.flag==1）{p=p->
++k;
else
SJF_time.flag!
=1）&
（（p->
service_time_min））
{service_time_min=p->
else{p=p->
r=q;
SJF_time.finish_time=q->
SJF_time.finish_time+p->
//q=p;
q=p;
}
}while（add_flag!
=num）;
for（p=head->
num>
0;
num--）//断开循环队列;
q->
指向链首，输出短作业调度后的进程信息p=head->
printf（********************************SJF*********************************\n）;
SJF_time.finish_time）;
SJF_time.turnaround_time）;
SJF_time.weigtharound_time）;
LinklistRR_scheduling（Linklisthead）//时间片轮转算法
Linklistp;
时间片大小intq_time;
//intnum=0;
//记录进程个数intadd_flag=0;
牰湩晴尨请输入时间片的大小:
q_time）;
RR_time.finish_time=0;
RR_time.turnaround_time=0;
RR_time.weigtharound_time=0;
RR_time.flag_time=p->
将创建的进程队列变为循环队列q->
//p=head->
RR_time.finish_time=p->
do{
/*printf（\
printf（**************************************************************\n）;
RR_time.finish_time）;
*/
服务时间大于时间片if（（p->
RR_time.flag_time）>
（q_time））//
RR_time.finish_time=（q->
RR_time.finish_time）+（q_time）;
//累加完成时间p->
RR_time.flag_time=（p->
RR_time.flag_time）-（q_time）;
if（（p->
=（p->
RR_time.finish_time））//有进程等待
{q=p;
当前进程未完成，无进程等待，指针不向后移//else
elseif（（p->
RR_time.flag_time）==0）//进程已经完成
else
RR_time.finish_time）+（p->
RR_time.flag_time）;
RR_time.flag_time=0;
++add_flag;
RR_time.turnaround_time=（p->
RR_time.finish_time）-（p->
RR_time.weigtharound_time=（float）（p->
RR_time.turnaround_time）/（p->
RR_time.finish_time））//有进程等待
{q=p;
else//当前进程完成，无进程等待，指针向后移
}//{q=p;
{p=p->
}whi
升级会员 