操作系统的实验一模拟进程状态转换.docx

操作系统的实验一模拟进程状态转换.docx

《操作系统的实验一模拟进程状态转换.docx》由会员分享，可在线阅读，更多相关《操作系统的实验一模拟进程状态转换.docx（10页珍藏版）》请在冰豆网上搜索。

操作系统的实验一模拟进程状态转换

实验一模拟进程状态转换及其PCB的变化

一、实验目的：

自行编制模拟程序，通过形象化的状态显示，使学生理解进程的概念、进程之间的状态转换及其所带来的PCB内容、组织的变化，理解进程与其PCB间的一一对应关系。

二、实验内容及要求：

（1）、设计并实现一个模拟进程状态转换及其相应PCB内容、组织结构变化的程序。

（2）、独立编写、调试程序。

进程的数目、进程的状态模型（三状态、五状态、七状态或其它）以及PCB的组织形式可自行选择。

（3）、合理设计与进程PCB相对应的数据结构。

PCB的内容要涵盖进程的基本信息、控制信息、资源需求及现场信息。

（4）、设计出可视性较好的界面，应能反映出进程状态的变化引起的对应PCB内容、组织结构的变化。

（5）、代码书写要规范，要适当地加入注释。

（6）、鼓励在实验中加入新的观点或想法，并加以实现。

（7）、认真进行预习，完成预习报告。

（8）、实验完成后，要认真总结，完成实验报告。

三、实现:

数据结构

structPCB{

charname;

intpriority;

intneedtime;

booloperator<（constPCB&b）const{

returnpriority>b.priority;

}

};

五状态进程模型

最高优先数优先调度算法流程图

四、运行结果：

图1创建2个进程，因为这时cpu空闲所以内核调度，b优先级高先执行

图2超时，因为这时cpu空闲所以内核调度，b优先级还是比a高所以先执行

图32个进程均被阻塞，其中一旦进程被阻塞就会引发调度

图4唤醒1个进程，从阻塞队列取队首放到就绪队列队尾，由于这时cpu空闲所以内核调度

五、源代码：

#include

#include

usingnamespacestd;

intReady_len=0;

intBlocked_len=0;

intCPU_state=0;

structPCB{

charname;

intpriority;

intneedtime;

booloperator<（constPCB&b）const{

returnpriority>b.priority;

}

};

PCBReady[100];

PCBBlocked[100];

PCBCpu;

booldispatch（）;

boolcreat（intNUM）{//创建一个新的进程

while（NUM--）{

printf（"输入进程名（一个字符）、所需时间（一个整数）、优先级（一个整数）:

\n"）;

scanf（"%s%d%d",&（Ready[Ready_len].name）,&（Ready[Ready_len].needtime）,&（Ready[Ready_len].priority））;getchar（）;

Ready_len++;

}

if（CPU_state==0）//如果CPU空闲，则调度

dispatch（）;

}

booldispatch（）{

if（CPU_state==0）{

if（Ready_len!

=0）{

sort（Ready,Ready+Ready_len）;

Cpu.name=Ready[0].name;Cpu.needtime=Ready[0].needtime;Cpu.priority=Ready[0].priority;

if（Ready_len!

=1）//就绪队列剔除队首元素

for（intindx=1;indx

Ready[indx-1].name=Ready[indx].name;Ready[indx-1].needtime=Ready[indx].needtime;Ready[indx-1].priority=Ready[indx].priority;

}

Ready_len--;

CPU_state=1;

printf（"***%c进程送往CPU执行\n",Cpu.name）;

Cpu.needtime--;

Cpu.priority--;

}else{

printf（"***就绪队列为空，无法调度\n"）;

returnfalse;

}

}else{

printf（"***CPU忙，无法调度\n"）;

}

}

booltime_out（）{

if（CPU_state==1）{

if（Cpu.needtime==0）

printf（"***%c时间片用完，并且执行完毕，被释放\n",Cpu.name）;

else{

Ready[Ready_len].name=Cpu.name;Ready[Ready_len].needtime=Cpu.needtime;Ready[Ready_len].priority=Cpu.priority;

Ready_len++;

printf（"***%c时间片用完\n",Cpu.name）;

}

CPU_state=0;

Cpu.name=0;

Cpu.needtime=0;

Cpu.priority=0;

if（Ready_len!

=0）//时间片用完，如果就绪队列不为空，则调度

dispatch（）;

}else{

printf（"***没有进程在CPU中，无法超时\n"）;

}

}

boolevent_wait（）{

if（CPU_state==1）{

Blocked[Blocked_len].name=Cpu.name;Blocked[Blocked_len].needtime=Cpu.needtime;Blocked[Blocked_len].priority=Cpu.priority;

Blocked_len++;

printf（"***%c被阻塞\n",Cpu.name）;

CPU_state=0;

if（Ready_len!

=0）//进程被阻塞，如果就绪队列不为空，则调度

dispatch（）;

}else

printf（"***没有进程在CPU中，无法阻塞\n"）;

}

boolevent_occur（）{

if（Blocked_len!

=0）{

//sort（Blocked,Blocked+Blocked_len）;

Ready[Ready_len].name=Blocked[0].name;Ready[Ready_len].needtime=Blocked[0].needtime;Ready[Ready_len].priority=Blocked[0].priority;

Ready_len++;

if（Blocked_len!

=1）//阻塞队列剔除队首元素

for（intindx=1;indx

Blocked[indx-1].name=Blocked[indx].name;Blocked[indx-1].needtime=Blocked[indx].needtime;Blocked[indx-1].priority=Blocked[indx].priority;

}

Blocked_len--;

//printf（"%d%d",Blocked_len,Ready_len）;

printf（"***%c被唤醒\n",Ready[Ready_len-1].name）;

if（CPU_state==0）//如果CPU空闲，则调度

dispatch（）;

//printf（"%d%d",Blocked_len,Ready_len）;

}else

printf（"***阻塞队列为空，无法唤醒\n"）;

}

intmain（）{

intCputime=1;

while

（1）{

printf（"\n1:

New\t\t\t2:

Dispatch\n"）;

printf（"3:

Timeout\t\t4:

Eventwait\n"）;

printf（"5:

Eventoccur\t\t0:

exit\n"）;

printf（"输入1--5实现相应的功能：

\n"）;

intselect;

scanf（"%d",&select）;getchar（）;

switch（select）{

case1:

intnum;

printf（"输入要创建的进程数：

\n"）;

scanf（"%d",&num）;

getchar（）;

creat（num）;

break;

case2:

dispatch（）;

break;

case3:

time_out（）;

break;

case4:

event_wait（）;

break;

case5:

event_occur（）;

break;

case0:

exit（0）;

break;

}

printf（"****************************Cputime:

%3d****************************\n",Cputime）;

printf（"状态\t\t进程名\t\t需要时间\t\t优先级\n"）;

if（CPU_state）{//显示CPU中的进程

printf（"Running:

\t%c\t\t",Cpu.name）;

printf（"%d\t\t\t",Cpu.needtime）;

printf（"%d\n",Cpu.priority）;

}

if（Ready_len）{//显示Ready队列中的进程

for（inta=0;a

printf（"Ready%d:

\t\t",a）;

printf（"%c\t\t",Ready[a].name）;

printf（"%d\t\t\t",Ready[a].needtime）;

printf（"%d\n",Ready[a].priority）;

}

}

if（Blocked_len）{//显示Blocked队列中的程序

for（intb=0;b

printf（"Blocked%d:

\t",b）;

printf（"%c\t\t",Blocked[b].name）;

printf（"%d\t\t\t",Blocked[b].needtime）;

printf（"%d\n",Blocked[b].priority）;

}

}

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

Cputime++;

}

}