2025年操作系统实验进程管理与调度实践解析

用IN学/多

操作系统试验汇报

学院计算机学院

专业08软件工程

班级___________04班______________

学号_________________

姓名刘贤生

指导教师_______________________

（12月）

度U多

计算机学院软件工程专业04班学号：_

姓名：刘贤生协作者：教师评估：

程序运行状况试验技能试验汇报

考勤状况

程序质量创新精神设计文档

试验.—题目进程调度第8周星期四

试验二题目-作业调度__________第10周星期四

试验三（综合性）题日主存空间的分派与回收第15周星期四

试验.四题目文献系统第16周星期四

试验平台：

】、计算机及操作系统：PC机，WindowsXP

2、编程环境：dp/plopc++60

源程序名和可执行程序名：

试验一：进程调度.c,进程调度.exe

试验二：单道—作业调度.c,单道一作业调度.exe

试验三（综合，性）：主存空间的分派与回收.c,主存空间的分派与回收.exe

试验四：文献管理.c,文献管理.exe

-N：/多

学号：―姓名：刘贤生协作者：

试验--题目进程调度-第8周星期一四

一、试验目的

用高级语言编写和调试一种进程调度程序，以加深对进程的概念及进程调度算法的理解。

二、试验内容和规定

进程调度，设计一种有'个进程并发的进程调度程序。规定采用最高优先数优先算法。

三、试验重要仪器设备和材料

试验环境

硬件环境：PC机

软件环境：develcpC++5.0

四、试验原理及设计方案

试验原理：把CPU分派给就绪队列中优先数最高的进程。

试验措施：采用“最高优先数”调度算法对五个进程进行调度，优先数高的先运行，优先数低

的进入就绪队列。

试验环节：

1、画出流程图

2、代码实现，其进程控制块定义为构造体pcb,如卜

关键代码如下:

#include<stdio.h>

#include<stdlib.h>

★include<string.h>

#inc1ude<conio.h>

typedefstructnode

(

charname[10];

intprio;

intround;

intcputime：

intneedtime;

intcount;

charstate:

structnode*nexl;

)PCB:

PCB"finish,"ready,*run;

intN;

firstinO

(

run=ready;

rnn->stato="R'：

ready=ready->next;

)

voidprtl()

(

print!("namecputimeneedtimecountroundstate\n*);

)

voidprt2(PCB*q)

(

prinIf(*%-8s%-8d%-8d%-6d%~5d%-c\n*,q->name,

q->cputime,q->needtim?,q->count,q->round,q->state);

)

voidprt()

(

PCB*p:

if(run!=NULL)

prt2(run);

p=ready;

while(p!=NULL)

{

prt2(p);

p=p->ncxt;

}

p=finish;

while(p!=NULL)

prt2(p):

p=p->next;

)

printf("Pressanykeytocontinue...\n*);

_getch();

prtlO;

}

insnrt(PCR*p?)

(

tail->next=p2;

tail=p2：

p2->next=NULL;

)

voidcroat()

(

PCD+p;

inti,time:

charna[10];

ready=NULL;

finish=NULL;

run=NULL;

print!("Enternameandtimcofroundprocess\n*);

for(i=l;i<=N;i++)

(

p=4nalloc(sizeof(MJB))：

scanf(飞s*,na):

scanf(飞d”,&lime);

strepy(p->name,na);

p->cputime=O;

p->necdtimc=timc;

p->count=0:

p->state-'w';

p->round=2：

if(ready!=NULL)

insert(p);

else

{

p->next=r?ady;

ready=p;

tail=p;

}

)

printf(woutputofround\n*);

prt10；

prt()：

run=ready;

rcady=roady->next;

run->stale='If;

roundrunO

(

while(run!=NULL)

(

run->cputime=run->cpulime+1：

run->ncedtimc=run->noedtime-l;

run->count=run->count+l;

if(run->needtime==O)

{

run->next=finish;

finish=rjn:

run->stat?=，F';

run=NULL;

if(ready!=NULL)

firstinO;

}

else

if(run->count==run->round)

(

run->2ount=0：

if(ready!=NULL)

run->state=*W';

insert(run);

firstinO;

)

)

prt();

)

)

mainO

printf("'Enterprocessnumber\n*);

scanf(飞d”,&N);

crealO;

rniindrun()：

)

五、成果分析以及调试小结

1、运行成果

D输入进程个数，建立进程控制块函数

Enterprocessnumber

5

Enternameandtimeofroundprocess

1

3

2

5

3

7

4

6

5

2

outputofround

nanecputineneedtimecountroundstate

10302w

20502w

30702w

40G02w

50202w

Press;anykeytocontinue...

nanecputineneedtinecountroundstate

2）查看进程的运行状况，输出目前的运行进程

0202w

Pt'-anykeytocontinue..■

nanecputineneedtinecountroundstate

20502R

30702w

40602w

50202w

2102W

Pressanykeytocontinue..■

nanecputineneedtimecountroundstate

21412R

30702w

E0602w

50202w

12102W

Pressanykeytocontinue..■

namecputineneedtinecountroundstate

30702R

40602w

50202w

2102W

b2302W

an9keytocontinue..■

Inanecputineneedtinecountroundstate

31612R

2、对成果的分析

在所有的进程都完毕之前，程序会一直循环运行，将目前运行的进程以及目前的就绪队列所有都

输出到屏幕上。

3、对调试过程中的小结

通过多次调试，不停地从原代码找出错误的地方，进行改正。最终程序的运行与成果都与预期的

同样，没有碰到什么大的困难。

六、心得体会

跟以往编程同样，要有耐心地调试程序，才能找到出错的地方，加以改正。

七、思索题

1、最高优先数的调度比较符合实际，按顾客设定的优先级别次序进行操作，而轮转法则比较公

平，按进队次序进行操作，并且每次进程运行一次后，无论完毕与否都要退出运行状态，让等待

队列的进程也能得届时间片去运行。最高优先数适合在进程数比较多的状况下对“有需要特殊照

顾”的进程优先，而轮转法则在进程数有较多短作业的时候使用，效果明显。

2、偏重于I/O型。

条4?4/多

学号：―姓名：刘贤生协作者：

试验一二一题目作业调度第10周星期四

一、试验目的

本试验规定学生模拟作业调度的实现，用高级语言编写和调试一种或多种作业调度的模拟程序,

理解作业调度在操作系统中的作用，以加深对作业调度算法的理解。

二、试验内容和规定

作业调度试验，为单道批处理系统设计一种作业调度程序

三、试验重要仪器设备和材料

试验环境

硬件环境：PC机

软件环境：develcpC++5.0

四、试验原理及设计方案

试验原理：编写一种单道处理系统实现作业的调度

试验措施：根据先来先服务、最短作业优先、响应比高考优先的调度算法实现作业调度，需要

计算出作业的平均周转时间和带权的平均周转时间。

试验环节：

1、画出流程图

I

2、代码实现，其有关数据构造阐明如下

关键代码如下：

#include"stdio.h"

#include<stdlib.h>

#include<conio.h>

tfdefinegetpch(type)(type*)malloc(sizeof(type))

//#defineNULL0

structworktime{

floatTb;

floatTc;

floatTi;

floatWi;）；

structjcb{

charname[10];

floatsubtine;

floatruntine;

//charresource;

floatRp;

charstate;

structworktimewt;

structjcb*link;

}*jcb_ready=NULL,*j;

typedefstructjcbJCB;

floatT=0;

voidsort()

(

JCB*first,"second;

intinsert=0;

if((jcb_reatiyMNULL)I|((j>subtime)<(jcb_ready>subtime)))

(

j->link=jcb_ready;

jcb_ready=j;

T=j->subtime;

j->Rp=l;

)

else

(

first=jcb_ready;

second=first->link;

while(second!=NULL)

{

if((j->subtime)<(second->subtime))

(

j->link=second;

first->link=j;

second=NULL;

insert=l;

}

else

(

first=first->link;

second=second->link;

)

)

if(insert==0)first->link=j;

}

)

voidSJFget()

|

JCB*front,♦mintime,*rear;

intipmove=0;

mintime=jcb_ready;

rear=mintime->link;

while(rear!=NULL)

if

((rear!=NULL)&&(T>=rear->subtime)&&(mintime->runtime)>(rear->runtime))

front=mintime;

mintime=rear;

rear=rear->link;

ipmove-1;

)

else

rear=rear->link;

if(ipmove=l){

front->link=mintime->link;

mintime->link=jcb_ready;

)

jcb_ready=mintime;

)

voidinput()

(

inti,num;

printf(*\n清输入作业数:“)；

scanf&num);

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

printf(*\n作业号No.%d:\n”,i);

j=getpch(JCB);

printf(*\n输入作业名：“)；

scanfj->name);

printf(*\n输入作业提交时刻:“)；

scanf("%f”,&j->subtime);

printf(*\n输入作业运行时间：”)；

scanf("%f”,&j->runtime);

printfC\n*);

j->state=,w';

j->link=NULL;

sort();

)

)

intspace()

(

int1=0;JCB*jr=jcb_ready;

while(jr!=NULL)

(

1++；

jr=jr->link;

)

return(1);

)

voiddisp(JCB*Jr,intselect)

(

printf(*\n作业服务时间运行时刻完毕时刻周转时间带权周转时间

\nO；

printf("|jr->name);

printf(*|%.2f\t*,jr->runtime);

f

if(j=jr){

printf("|%.2f\t”,jr->wt.Tb);

printf(*|%.2fjr->wt.Tc);

printf(*|%.2f\t*»jr->wt.Ti);

printf(*|%.2f”,jr->wt.Wi);

)

printf('\n");

)

voidcheck(intselect)

(

JCB*jr;

printf(*\n♦*♦*目前正在运行的作业是:％s",j->name);

disp(j,select);

jr=jcb_ready;

printf("\n♦***目前就绪队列状态为:\n");

while(jr!=NULL)

jr->Rp=(T-jr->subtime)/jr->runtime;

disp(jr,select);

jr=jr->link;

)

destroy();

)

intdestroy0

(

printf(*\n作业［%s］己完毕.\n”,j->name);

free(j);

}

voidrunning(JCB*jr)

(

if(T>=jr->subtime)jr->wt.Tb=T;elsejr->wt.Tb=jr->subtime;

jr->wt.Tc=jr->wt.Tb+jr->runtime;

jr>wt.Ti-jr>wt.Tcjr>subtime;

jr->wt.Wi=jr->wt.Ti/jr->runtime;

T=jr->wt.Tc;

)

intmain()

(

intselect=0,len,h=0;

floatsumTi=0,sumWi=0;

input();

len=space();

printf(*\n\tl.FCFS2.SJF3.HRN\n\n请选择作业调度算法:？”)；

scanfIselect);

while((len!=0)&&(jcb_ready!=NULL))

(

h++;

printf(*\n执行第%d个作业\n”,h);

j=jcb_ready;

jcb_ready=j->link;

j->link=NULL;

j->state=,R';

running(j);

sumTi+=;->wt.Ti;

sumWi+=;->wt.Wi;

check(select);

if(select==24&h<len-l)SJFget()：

printfC\n按任一键继续.....\n*);

getcharO;

getchar（）;

）

printf（*\n\n作业已经完毕.\n"）;

printf（*\t此组作业的平均周转时间：%.2f\n*»sumTi/h）;

printf（*\t此组作业的带权平均周转时间：%.2f\n\sumWi/h）;

getchar（）;

）

）五、成果分析以及调试小结

1、运行成果

运行界面

请输入作业数

作业号No.0：

输入作业名：one

输入作业提交时刻：2

输入作业运行时间：4

作业号No.

输入作业名：two

输入作业提交时刻：4

输入作业运行时间：3

作业号No.2：

输入作业名：thi'ee

D选择了先来先服务算法进行实例，输入数据

输入作业运行时间

l.FCFS2.SJF3.HRN

请选择作业调度算法:?]

运行状况及分析:

执行第1个作业

****当前正在运行的作业是:。ne

作业服务时间运行时刻完成时刻周转时叵带权周转时间

：one：4.00：2.00：6.00：4.00：1.00

*****当前就绪队列状态为：

作业服务时间运行时刻完成时刻周转时i瓦带权周转时间

■two53.00

作业服务时间运行时刻完成时刻周转时间带权周转时间

'three'7.00

作业Cone］已完成.

按任一键继续……

2）选择了短作'也优先算法进行实例，输入数据

1F21LloneJ匕兀只乂.

按任一键继续……

执行第2个作业

****当前正在运行的作业是:U。

作业服务时间运行日赛U完成时刻周转时间带权周转时间

；two；3.00；6.00!9.00；5.0051.67

””当前就绪队列状态为：

作业服务时间运行时刻完成时刻周转时间带权周转时间

•three!7.00

作业［Mo］已完成.

按任一键继续……

2、对成果的分析

几经修改，终于得出对的的成果，运行成果的输出不够明显，尚有待修改。

3、对调试过程中的小结

成果的输出很繁杂，要仔细辨别每一种的含义，与理论上的成果进行对比，然后找出bug,再进

行校正。

六、思索题

1、FCFS算:法逻辑思绪比较简朴，直接按进程抵达时刻进行排序就可以了，而短作业和最高响应

比这两个算法则规定对进程参数做一番比较才能排序，并且在一种进程完毕后还要重新对队

列中的进程进行排序。由此可见，FCFS的长处就是编写以便，但由于次序是固定的，产没有

对进程的优先级别进行考虑，不那么符合实际：短作业的长处就是可•以在行长作业的队列里

先优先短作业的操作，不用由于等待长作业而拖慢了运行时间，最高响应比则比较符合实际,

按“需”进行排序，但这两种算法在进程比较少的状况卜.效果不如FCFS明显，并且在编写的

时候要尾慎考虑其逻辑思绪，防止出错。因此，在进程较少的状况下首先可以选用的是FCFS,

而在进程较多的状况下则看需要采用短作业或者高响应比效果会好些。

2、面向顾客的准则：周转时间短：响应时间快：截止时间的保证：优先权准则

面向系统的准则：系统吞吐量高：处理机运用率好：各类资源的平衡运用

条4/4/多

学号：_姓名：刘贤生协作者：

试验三题目主存空间的分派与回收第15周星期_0_

一、试验目的

熟悉主存的分派与回收。理解在不一样的存储管理方式下，怎样实现主存空间的分派与回

收。掌握动态分辨别配方式中的数据构造和分派算法及动态分区存储管理方式及其实现过程。

一、试验内容和规定

主存空间的分派和回收，试验规定使用可变分区存储管理方式，分辨别配中所用的数据构造

采用空闲分区表和空闲分区链来进行，分辨别配中所用的算法采用初次适应算法、循环初次适应

算法、最佳适应算法三种算法来实现主存的分派与回收。同步，规定设计一种实用友好的顾客界

面，并显示分派与回收的过程。

三、试验重要仪器设备和材料

试验环境：

硬件环境：PC机,WindowsXP

软件环境：developC++5.0

四、试验原理及设计方案

试验原理：可变分区管理是指在处理作业过程中建立分区，使分区大小恰好适合作业的需求，并

且分区个数是可以调整的。当要装入一种作业时，根据作业需要的主存量查看与否有足够的空闲

空间，若有，则按需要量分割一种分辨别配给该作业：若无，则作业不能装入，作业等待。伴随

作业的装入、完毕，主存空间被提成许多大大小小的分区，有的分区被作业占用，而有的分区是

空闲的。

试验措施：采用可变分区存储管理，用fif。算法设计主存分派和回收程序。

试验环节：

1、画出流程图

2、关键代码，其有关数据构造如下

关键代码如下：

#include<stdio.h>

#include<stdlib.h)

#include<conio.h>

^include〈time,h)

Sinclude<string.h>

#definegetpch(typc)(type*)malloc(sizeof(type))

才defineMEMTT0

^defineleast50

structfen(

charname[10]

intsize;

intstart：

intend：

intstate;

intstartimo;

intendtime:

structfen*ncxt;

structfen+prc;

}*freetab=NULL,*ful1=NUI.L,*second=XUI.L,*fullend=NUI.L,*p=NULL,*tempfen=NULI.;

structpcb{

charname[10]

intstartime

intneedtime

intendtime;

intsize：

structpcb*ink：

}*ready=NliLL,*tcrapeb=NULL,*wait=NULL：

intsysT=O;

intfreetablt=MEMTT：

intmaxsize=0;

voidaddfreetabO:

voidprintpeb()

structpcb*tcmp=ready：

printf(*\n\n日靖队列如下：\n\n");

while(temp!=NVLL)

printf("作业名:\t待提交时间:\t所需时间:\n");

printf(飞s\l\ttemp->name,temp->slartime,temp->needtime);

temp=tem^->link：

//getch(>：

}

getch()：

tomp=wait;

printf("\n\n等待队列如下：\n\n");

while(temp!=NUl.l.)

{

//getch0：

printf("作业名:\t所需时间:\t所需内存、n");

printf{飞tcmp->narae,tcmp-)necdtime,tcmp->size);

tcmp=temo->link;

}

getch()：

}

printO

(

structfen*tcmp=freetab：

//clrscrO;

system("cls")

printf("空闲内存如下：\n\rT);

while(temp!=NULL)

(

printf("起始地址：\t大小:\t结束地址\n.);

prinlf(飞temp->start,temp>size,temp>slart+lemp->size);

tcmp=tem3->next;

//getch0;

}

getch();

temp=full;

prinlf("\n'n内存作业块如下：\n\n*);

while(teinp!=NULL)

{

printfC1名字：\t起始地址：\l大小：进入内存时间：\t结束时间：\n");

printf■(飞s\t蒋d\t\t*d\t%d\t\t%d\rT,tomp->name,tcmp->start,tomp->size,temp->startimo,tomp->cndt

ime);

tcmp=tem^->next;

}

getch()：

}

sort()

{

structpcb*f;rst,"second：

intinsert=0：

if((ready==NULL)I((tempcb->startime)<(ready->startime)))/*申清时间最早者,插入队}*/

{

Icmpcb->1ink=ready:

ready=tempcb：

}

else

first=ready：

second=first->link;

while(second!=NUI.L)

if((tcmpcb->startime)<(sccond->startinc))

tempcb->link=sccond;

first->link=terapcb：

second=NULL：

insert=l：

)

else

first=first->link:

second=second->link;

)

)

if(insert==O)first->link=tempcb;

)

)

input()

{

inti,num;

syslcm("cls"):

printf「\n请谕入作业总数?”)；

scanf&num);

for(i-0;i<numi++)

(

printf(*\n作业号No.i);

tempcb=g?tpch(struetpeb);

printf(*\n输入作业名

scanW,lempcb->name);

prinlf(\n输入作业提交时间

scan1■(飞广，&lempcb->slarlime);

printf（"\n输入作业运行时间

scanf(*%>1*,4tempcb->needtime);

printf(*\n*);

tcmpcb->?ndtimo=tompcb->startimc+1empcb->n(edtimo;

tempcb->link=NULL;

sort();

voidinit()

charch='y';

printf（*\n\t开始初始空闲表\n"）;

while(ch!='n'；

p=getpch(structfen)：

printf（"\n\t请输入空闲块的起址和大小\n"）:

scanf%d*.&p->start.&p->size):

if(p->si!e<50)

printfr\n\t空闲块太小没故意义，程序自动将其修改成%d\n"Jeasl）;

p->size=least：

)

p->pre=N'JLL;p->next=NULL：

p->slale=0:

addfreetab();

print()：

printfC\n\t假如不需要继续揄入空闲表请输入n\n'i");

getcharO;

ch=getchar();

)

p=frcctab：

while(p!=NUI.I.'

{

if(p->sizc>maxsizc)maxsizo=p->sizc:

p=p->next;

}

input()：

}

add(structfen*temp)

{

p->state=O;

if((temp->start+terap->size)>=p->start)

(

if(temp->start+temp->size<p->start+p->size)

lenp->size=p->size+p->start-terap->start;

free(p);

p=lemp;

printfC\n回收(输入)的空闱块与前面的块相邻(交)，已合并\n");

getchO;

else

(

p->pre=temp;

p->next=tcmp->nexl：

temp->neKt=p:

p->next->pre=p:

temp=p;

}

p=temp：

if(p->next!=NULL)

if((p->5tart+p->size)>=p->next->start)

(

if(p->start+p->size<p->next->start+p->next->size)

p->size=p->noxt->start+p->next->sizc-p->start;

tenp=temp->next;

p->next=temp->next;

if(temp->ncxt!=NUL[.)

temp->next->pre=p;

free(temp);

printfC\n回收(输入)的空闲块与背面的块相邻(交)，已合并\n")：

gctchO;

)

|

voidaddfreetabO

(

intflag=l;

if(freetab==NULL){freetab-p;return;?

else

(

if((p->start)<(freetab->start))

f

if((p->start+p->size)>=freetab->start)

(

if(freetab->start+freetab->size(p->start+p->size)

freetab>size=p>size;

else

freetab->size=Freelab->start+freetab->size-p->slart;

freetab->start=p->start:

free(p);

printf(*\n回收(输入)的空闲块与背面的块相邻(交,含),己合并\n");

getchO;

)

else

(

frcctab->pre=p;

p->next=freetab：

freetab=p;

}

return;

)

else

second二freetab;

whilc(second->next!=NULL)

(

if((p->start)<(second->next->start))

{

add(second)：

flag=O;

break;

)

elsesecond=second->next;

)

if(flag)

(

if((second->start+second->size)>=p->start)

(

i((second>start+second->size<p->start+p->size)

second->size=p>size»p>startsecond>slart;

free(p);

printf(*\n回收(输入)的空闲块与前面的块相邻(交,含)，己合并\n0;

getchO;

}

else

{

p->pre=second;

second->next=p;

p->next=NULL;

)

I

)

}

)

addful1(structfen*temp)

{

structfen*frst,*second：

intinsert=0;

if((full—NULL)|((temp->endtime)<(lemp->endtime)))

temp->ne>it=ful1;

full=ten©:

}

else

first=full:

second=first->next:

while(second!=NUI.L)

if((temp->endtime)<(second->endtime))

temp->next=sccond;

first->ncxt=temp;

second=NULL：

insert=l：

)

else

first=first->next:

second=second->next:

)

)

if(insert==O)first->next=temp;

}

)

addwaitO

structpcb*frst,"second;

intinscrt=0;

if((wait=NULL)I((tempcb->size)<(wait->size)))

tcmpcb->link=wait;

wait=tcmpcb：

else

first=wait：

second=first->link：

while(second!=NULL)

if((tempcb>size)<(second->size))

tcmpcb->link=second：

first->link=tempcb;

second=NULL:

insert=l：

)

else

(

first=first->link;

second=socond->link：

}

)

if(insert-=O)first->link=tempcb;

}

)

intdevideO

{

structfen*lcmp:

system("cls");

p=freetab;

while(p!=Nl-LL；

if((tempcb->size<=p->size))

if((p->size-tempcb->size)<least)

p->state=l;

p-)startime=sysT:

p->endtime=sysT+tempcb->needtime;

strcpy(p->name,tempcb->name)：

if<p=freetab)

{

frcetab=frcctab->noxt;

)

else

p->prc->next=p->noxt;

if(p->next!=NULL)

p->next->pre=p->pre;

p-)pre=NULL;

p->ncxt=NLLL;

printf(*\n\t分派成功！\n\t作业分派到的内存首地址是\t加大，.、为：

\t%d\n*,p->start,p->size)：

getch();

adcful1(p)：

printpcbO;

return1;

}

else

(

temp=getpch(struetfen)：

temp->next=NULL;

temp->pre=NULL：

temp->slale=l:

tcmp->startime=sysT;

temp->endtime=sysT+tempcb->nee<ltime;

temp->size=lempcb->size;

strepy(lcmp->name,tempcb->nanic);

temp->slart=p>start;

p->start+=tempcb->size;

p->size=p->size-tcmpcb->size;

addfull(temp);

printf(M\n\t分派成功！\n\t作业分派到的内存首地址是:\t%d\t大小为:

\lM\n”,iemp->starl,temp->size):

getchO;

return1：

)

)

elsep=p->next：

printf(\n\t分派不成功！\n\t作业所需内存太大，现无合适块分派，将被放到等待队列\n");

acldwai10：

return0：

runingO

{

intflag;

while(ready!=NULL11wait!=NULL||full!=NULL)

(

sysT++：

printf(*\n\t目前时间:\t%d\n*,sysT);

getchO;

if(full!=NULL)

(

while(ful1!=NULL&&full->endtime<=sysT'

(

printf("\n作业他已经运行完，其所占用的空间将被回收\n”,full->name);

printf("\n回收的内存块如下\n'n");

printf("寄存作业:\1起始地址：\t大小：\t结束时间:\n");

printf("%s\t\t%d\t\t%d\t%d\n\n\n*',full->name,full->start,full->size,full->endtime):

getchO:

p=full:

full=full->next;

p->next=NULL：

p->pre=NULL;

addfreetabO:

printO;

printpcbO：

)

if(wait!=NULL)

tempcb=wait：

wait=wait->link;

printf("\n\t1等待队列|中的作业%s申请进入内存tcmpcb->name);

getchO：

flag=devide();

if(!flag)2门加《飞八。等待队列|中的作业%s申请进入内存K成功

\n”,tempcb->name)：getchO；｝

else

|

printO;

printpcbO；

)

1

while(wait!=NUl.l^：&flag)：

)

if(ready!=NULL)

while(ready!=NULI^i&ready->startime<=sysT)

tempcb=ready;

ready=ready->link;

tempcb->link=NULL:

printf(*\n\n\t|申请队列|中的作业％s抵达预定申请内存时

间：%d\n*,tempcb->name,tempcb->startime)：

getchO;

printf("\t请为该作业输入所需内存数\n");

scanf("%(!*,&tempcb->size)：

while(tompcb->size>maxsize)

{

printf("所需内存数不小于空闪表也许最大块，请重输\n");

scand&tompcb->sizc);

}

if(tcmpcb->sizc<least)

{

printf("\n所需内存数不不小于分派下限，系统为其分派内存数将是下

限%d\n”,least);

tcrapcb->size=least：

getchO;

}

if(devide())

|