操作系统进程调度编程Word文件下载.docx
- 文档编号:21346776
- 上传时间:2023-01-29
- 格式:DOCX
- 页数:43
- 大小:235.72KB
操作系统进程调度编程Word文件下载.docx
《操作系统进程调度编程Word文件下载.docx》由会员分享,可在线阅读,更多相关《操作系统进程调度编程Word文件下载.docx(43页珍藏版)》请在冰豆网上搜索。
4.memset(process,0,sizeof(process));
5.//读入调度类型
6.inttype;
7.scanf("
%d"
&
type);
8.//读入调度进程数据
9.for(n=0;
~scanf("
%d/%d/%d/%d/%d"
10.&
process[n].id,
11.&
process[n].arrive,
12.&
process[n].run,
13.&
process[n].priority,
14.&
process[n].time);
n++);
15.//根据调度类型转到子程序进行调度
16.switch(type)
17.{
18.//各调度子程序:
19.case1:
fcfs();
break;
//先来先服务
20.case2:
sjf();
//短作业优先
21.case3:
sltf();
//最短剩余时间优先
22.case4:
tpt();
//时间片轮转
23.case5:
dp();
//动态优先级
24.}
25.return0;
26.}
(2).先来先服务
算法逻辑流程
本题中算法实际流程
1.voidfcfs()
3.//按到达时间、pid排序
4.sort(process,process+n,cmp_ar_id);
5.//初始化系统时间
6.inttime=0;
7.//顺序遍历各进程
8.for(inti=0;
i<
n;
i++)
9.{
10.//若当前系统时间时没有待调度进程
11.if(time<
process[i].arrive)
12.{
13.//等待系统时间到达下一个进程到来
14.time=process[i].arrive;
15.}
16.//否则
17.//进行进程调度
18.printf("
%d/%d/%d/%d/%d\n"
i+1,process[i].id,time,time+process[i].run,process[i].priority);
19.//进程运行,系统时间流逝
20.time+=process[i].run;
21.}
22.return;
23.}
(3).短作业优先
1.voidsjf()
3.//按运行时间、pid排序
4.sort(process,process+n,cmp_run_id);
7.//有未运行进程
8.for(intm=1;
m<
=n;
)
10.//找出已到达的未运行进程中,运行时间最短的进程
11.intmin=INT_MAX,mini=-1;
12.for(inti=0;
13.{
14.if(process[i].arrive<
=time&
&
//已到达的进程
15.process[i].run<
min&
//运行时间最短的进程
16.!
process[i].done)//未运行的进程
18.min=process[i].run;
19.mini=i;
20.}
22.//若当前系统时间时没有待调度进程
23.if(-1==mini)
24.{
25.//找出下一个到达的时间
26.intmint=INT_MAX;
27.for(inti=0;
28.{
29.if(process[i].arrive<
mint&
//最近的到达时间
30.!
31.{
32.mint=process[i].arrive;
33.}
34.}
35.//等待系统时间到达下一个进程到来
36.time=mint;
37.continue;
38.}
39.//否则
40.//进行进程调度
41.printf("
m,process[mini].id,time,time+process[mini].run,process[mini].priority);
42.//进程运行,系统时间流逝
43.time+=process[mini].run;
44.process[mini].done=true;
45.//已运行进程数+1
46.m++;
47.}
48.}
(4).最短剩余时间优先
主流程:
调度器配置阶段:
预调度阶段:
进程调度阶段:
进程运行阶段:
1.voidsltf()
3./**********调度器配置阶段**********/
4.//按到达时间、运行时间、pid排序
5.sort(process,process+n,cmp_run);
6.//初始化系统时间
7.inttime=process[0].arrive;
8.//初始化调度程序配置
9.intexeci=-1,start=time;
10.intk=0,m=0;
11.//有未运行进程
14./**********预调度阶段**********/
15.//找到在当前系统时间已经到达的进程
16.for(;
process[i].arrive<
i++);
17.//在已到达进程中查找剩余运行时间最短的未结束进程
18.intmin=INT_MAX,mini=-1;
19.for(intj=0;
j<
i;
j++)
20.{
21.if(process[j].run<
!
process[j].done)
22.{
23.min=process[j].run;
24.mini=j;
25.}
26.}
27.//若在当前系统时间之前到达的进程均已经结束
28.if(-1==mini)
29.{
30.//等待下一个进程到达后重新进行调度
31.time=process[i].arrive;
32.continue;
34.//若当前没有正在运行的进程
35.if(-1==execi)
36.{
37.//则执行找到的进程
38.execi=mini;
39.//进程的开始运行时间设为现在的时间
40.start=std:
:
max(process[execi].arrive,time);
41.}
42./**********进程调度阶段**********/
43.//若找到的进程剩余运行时间小于当前正在运行进程的剩余运行时间
44.if(process[mini].run<
process[execi].run)
45.{
46.//则进行调度
47.printf("
++k,process[execi].id,start,time,process[execi].priority);
48.execi=mini;
49.start=time;
50.}
51./**********进程运行阶段**********/
52.//运行进程
53.intrunnable=process[i].arrive-time;
54.//若进程可以完成运行则将进程运行完
55.if(runnable>
=process[execi].run||runnable<
=0)
56.{
57.time+=process[execi].run;
58.printf("
59.process[execi].run=0;
60.process[execi].done=true;
61.m++;
62.execi=-1;
63.start=time;
64.}
65.//若进程不能完成运行则运行一个时间片
66.else
67.{
68.time+=runnable;
69.process[execi].run-=runnable;
70.}
71.}
72.return;
73.}
74.
(5).时间片轮转
1.voidtpt()
3.//初始化进程队列
4.queue<
pcb>
qu;
5.process[n].arrive=INT_MAX;
6.//按到达时间、pid排序
7.sort(process,process+n,cmp_ar_id);
8.//初始化系统时间
9.inttime=process[0].arrive;
10.//所有进程是否均完成运行
11.for(inti=0,k=1,m=0;
13.//如果队列为空
14.if(qu.empty())
15.{
16.//等待新的进程到达
17.time=process[i].arrive;
18.//将当前系统时间之前的进程放入队列
19.for(;
21.qu.push(process[i]);
22.}
23.}
24.//取队首进程
25.pcbtemp=qu.front();
26.qu.pop();
27.//如果进程不能完成运行
28.if(temp.run>
temp.time)
30.//进程调度
31.printf("
k++,temp.id,time,time+temp.time,temp.priority);
32.//将进程运行一个时间片
33.time+=temp.time;
34.temp.run-=temp.time;
35.//将当前系统时间之前的进程放入队列
36.for(;
37.{
38.qu.push(process[i]);
39.}
40.//将进程放回队列
41.qu.push(temp);
42.}
43.//如果进程可以完成运行
44.else
46.//进程调度
k++,temp.id,time,time+temp.run,temp.priority);
48.//将进程运行完
49.time+=temp.run;
50.//将当前系统时间之前的进程放入队列
51.for(;
52.{
53.qu.push(process[i]);
54.}
55.m++;
56.}
57.}
58.return;
59.}
(6).动态优先级
1.voiddp()
6.inttime=process[0].arrive;
7.intlast=time;
8.intmin,mini=-1;
9.for(inti=0,k=1,m=0;
10.{
11.//找到在当前系统时间已经到达的进程
12.for(;
14.//若进程在时间片中间到达,则算作是运行了一个时间片,优先级+1
15.if(last<
process[i].arrive&
time)
16.{
17.process[i].priority=(process[i].priority-1>
0)?
(process[i].priority-1):
0;
18.}
19.}
20.//找到优先级最高的进程
21.min=INT_MAX,mini=-1;
22.for(intj=0;
23.{
24.if(process[j].priority<
25.{
26.min=process[j].priority;
27.mini=j;
28.}
29.}
30.//若在当前系统时间之前到达的进程均已经结束
31.if(-1==mini)
32.{
33.//等待下一个进程到达后重新进行调度
34.time=process[i].arrive;
35.continue;
36.}
37.last=time;
38.//如果进程可以运行完
39.if(process[mini].run<
=process[mini].time)
40.{
41.//进程调度
42.printf("
k++,process[mini].id,time,time+process[mini].run,process[mini].priority+3);
43.//将进程运行完
44.m++;
45.time+=process[mini].run;
46.process[mini].done=true;
48.//如果进程不能运行完
49.else
50.{
51.//进程调度
52.printf("
k++,process[mini].id,time,time+process[mini].time,process[mini].priority+3);
53.//将进程运行一个时间片
54.time+=process[mini].time;
55.process[mini].run-=process[mini].time;
57.//调整进程优先级
58.for(intj=0;
59.{
60.if(!
61.{
62.//若被运行,优先级-3
63.if(j==mini)
64.{
65.process[j].priority+=3;
66.}
67.//若未被运行,优先级+1
68.else
69.{
70.process[j].priority=
71.(process[j].priority-1>
(process[j].priority-1):
72.}
73.}
74.}
75.}
76.return;
77.}
6.程序完整代码及注释
#include<
algorithm>
queue>
cstdio>
climits>
cstring>
usingstd:
sort;
queue;
constintN=100;
//定义PCB数组大小
intn;
//保存进程的总个数
structpcb//PCB(进程控制块)
{
intid;
//进程号pid
intarrive;
//进程到达时间
intrun;
//进程运行时间
intpriority;
//进程优先级
inttime;
//进程运行的时间片
booldone;
//记录进程是否已经完成运行
}process[N];
//PCB数组
//按到达时间、pid排序
boolcmp_ar_id(pcba,pcbb)
if(a.arrive==b.arrive)
{
returna.id<
b.id;
}
else
returna.arrive<
b.arrive;
}
//按运行时间、pid排序
boolcmp_run_id(pcba,pcbb)
if(a.run==b.run)
returna.run<
b.run;
//按到达时间、运行时间、pid排序
boolcmp_run(pcba,pcbb)
//先来先服务
voidfcfs()
//按到达时间、pid排序
sort(process,process+n,cmp_ar_id);
//初始化系统时间
inttime=0;
//顺序遍历各进程
for(inti=0;
//若当前系统时间时没有待调度进程
if(time<
//等待系统时间到达下一个进程到来
time=process[i].arrive;
//否则
//进行进程调度
printf("
//进程运行,系统时间流逝
time+=process[i].run;
return;
//短作业优先
voidsjf()
//按运行时间、pid排序
sort(process,process+n,cmp_run_id);
//有未运行进程
for(intm=1;
//找出已到达的未运行进程中,运行时间最短的进程
intmin=INT_MAX,mini=-1;
if(process[i].arrive<
process[i].run<
min=process[i].run;
mini=i;
if(-1==mini)
//找出下一个到达的时间
intmint=INT_MAX;
p
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 操作系统 进程 调度 编程
![提示](https://static.bdocx.com/images/bang_tan.gif)