课程设计1

采用的是C++语言编写的，但PCB的数据结构是符合要求的。

题目1：模拟进程调度

一、设计目的

1、理解PCB

2、理解进程的并发执行

3、理解进程的FCFS、动态优先权和时间片轮转三种调度算法，并模拟实现这三种算法

二、设计要求

1、PCB在本设计中的基本结构

Typedefstructnode

{

Char name[10]；/*进程标识符*/

Int prin；/*进程的优先级*/

Int round；/*进程轮转的时间片*/

Int needtime；/*进程还需要的cpu时间*/

Int waittime；/*进程进入系统后等待cpu的时间*/

Char state；/*进程的状态*/

Struct node *next；/*链接指针*/

}PCB

设计三个队列：就绪、完成、运行，其中运行队列中应该只有一个进程。

创建进程，就是用户输入进程的标识符和运行所需时间，系统为其生成一个PCB，存放进程的信息，将新生成的PCB插入就绪队列。进程任务结束，系统将其PCB插入完成队列，该进程就消亡。

2、动态优先权调度算法模拟：

优先权= 1 + 等待时间/需要服务时间----最高响应比优先

(1) 输入一批作业的进程标识和估计运行时间，将其PCB插入就绪队列

(2) 当就绪队列非空、CPU空闲时，计算出每个就绪进程的优先权

(3) 将优先权最高的进程从就绪队列移入运行队列，状态改为运行

(4) 在屏幕上输出当前所有进程的状态和优先权信息(已完成进程不需此项)

(5) 让运行进程执行足够的服务时间

(6) 将运行进程移入完成队列

(7) 提示可以输入新的作业，如果有新作业输入，则转向(1) ，否则转向(2)

(8) 如果就绪队列为空，则结束

3、时间片轮转调度算法模拟

输入一批作业的进程标识和估计运行时间，由其PCB组成就绪队列。时间片轮转调度，系统要给就绪队列的第一个进程分配一个时间片，大小等于n (个时钟周期)，再将它移入运行队列。注意，时间片的大小要比大多数进程的估计运行时间短。当时间片结束的时候，要将没有运行完的进程从运行队列移到就绪队列的末尾，再次进行调度。在每次调度时将所有进程的当前情况显示出来。

4、FCFS调度算法模拟

按一定的顺序输入一批作业的进程标识和估计运行时间，由其PCB按照进程标识输入的顺序组成就绪队列。当就绪队列非空、CPU空闲时，将就绪队列的第一个进程从就绪队列移入运行队列，状态改为运行。以后个步骤类似于2。

把源码也贴下来吧！！！

/***********模拟进程调度2009.12.30biao************/
#include"stdafx.h"
#include<stdio.h>
#include<iostream>
#include<string>
#include<windows.h>
#include<ctype.h>
#include<iomanip>
#defineMAX10//最大进程数
#defineROUND2//进程时间片默认为2
intflag;
intamount;
intflagf=0;
usingnamespacestd;
classPCB
{
stringname;/*进程标识符*/
floatprin;/*进程的优先级*/
intround;/*进程轮转的时间片*/
floatneedtime;/*进程还需要的cpu时间*/
floatwaittime;/*进程进入系统后等待cpu的时间*/
stringstate;/*进程的状态*/
public:
voidsetname(){
stringm;
cout<<"标识符:";
cin>>m;
name=m;
}
voidsetprin(floatp){
prin=p;
}
voidsetround(){
round=ROUND;
}
voidsetround(intr){
round=r;
}
voidsetneedtime(){
floatn;
cout<<"执行时间：";
cin>>n;
needtime=n;
}
voidsetneedtime(floatt){
needtime=t;
}
voidsetwaittime(floatw){
waittime=w;
}
voidsetstate(strings){
state=s;
}
stringgetname(){
returnname;
}
floatgetprin(){
returnprin;
}
intgetround(){
returnround;
}
floatgetneedtime(){
returnneedtime;
}
floatgetwaittime(){
returnwaittime;
}
stringgetstate(){
returnstate;
}
};
classpro{/*一批进程*/
private:
PCBproready[MAX];
PCBrunpro;
PCBfinishpro[MAX];
public:
intinput(){
//booltestName;//作为测试进程唯一的标志。
stringyes;
stringst1="ready";
cout<<endl;
cout<<"请输入进程数量(最大进程数为10):"<<endl;
cin>>amount;
while(amount<=0||amount>21){
cin.clear();
cin.ignore(1000,'/n');
cout<<"请输入合法进程数量!"<<endl;
cin>>amount;
}
cout<<"选择调度算法：1.动态优先权2.时间片轮转3.FCFS"<<endl;
cin>>flag;
while(flag!=1&&flag!=2&&flag!=3){
cin.clear();
cin.ignore(1000,'/n');
cout<<"选择调度算法：1.动态优先权2.时间片轮转3.FCFS"<<endl;
cin>>flag;
}
if(flag==1){//动态优先权
for(intj=0;j<amount;j++){
proready[j].setname();
testName1(proready,j);
proready[j].setneedtime();
proready[j].setwaittime(0);
proready[j].setround(0);
proready[j].setstate(st1);
proready[j].setprin(1);
cout<<endl;
}
cout<<"*************执行动态优先权排列插入就绪队列**************"<<endl;
dynamicsort(proready,amount);
show(proready,amount);
cout<<endl;
dynamicrun(proready,amount);
}
elseif(flag==2){
for(intj=0;j<amount;j++){
proready[j].setname();
testName1(proready,j);
proready[j].setprin(j);
proready[j].setneedtime();
proready[j].setwaittime(0);
proready[j].setround();
proready[j].setstate(st1);
cout<<endl;
}
cout<<"*************算法：时间片轮转执行调度的就绪队列**********"<<endl;
show(proready,amount);
cout<<endl;
timeround(proready,amount);
}
elseif(flag==3){
for(intj=0;j<amount;j++){
proready[j].setname();
testName1(proready,j);
proready[j].setprin(j);
proready[j].setneedtime();
proready[j].setwaittime(0);
proready[j].setround(0);
proready[j].setstate(st1);
cout<<endl;
}
cout<<"*************算法：FCFS执行调度的就绪队列**********"<<endl;
show(proready,amount);
cout<<endl;
FCFS(proready,amount);
}
cout<<endl;
cout<<"继续？（Y/N）:";
cin>>yes;
if(yes=="Y"||yes=="y"){
return1;
}
else{
return0;
}
}
voidtestName1(PCBproready[],intj){//判断进程名的唯一性
booltestName=true;
while(testName){
if(j>0){
for(inti=0;i<j;i++){
if(proready[j].getname()==proready[i].getname()){
cout<<"在就绪队列中，已存在该进程名，请重新输入进程名."<<endl;
proready[j].setname();
break;
}else{
testName=false;
}
}
}else
testName=false;
}
}
voiddynamicsort(PCBproready[],inti){//动态排列就绪队列
PCBtemp1;
for(intj=0;j<i;j++){
for(intk=0;k<i;k++){
if(proready[k].getprin()<proready[k+1].getprin()){
temp1=proready[k];
proready[k]=proready[k+1];
proready[k+1]=temp1;
}
}
}
}
voidshow(PCBpro1[],inti){//显示进程信息
cout<<"name"<<setw(10)<<"prin"<<setw(10)<<"round"<<setw(10)<<"needtime"<<setw(10)<<"waittime"<<setw(10)<<"state"<<endl;
for(intj=0;j<i;j++){
if(pro1[j].getstate()=="run"){
cout<<setw(2)<<pro1[j].getname()<<setw(10)<<pro1[j].getprin()<<setw(10)<<pro1[j].getround()<<setw(10)<<pro1[j].getneedtime()<<setw(10)<<pro1[j].getwaittime()<<setw(10)<<pro1[j].getstate()<<endl;
}elseif(pro1[j].getstate()=="ready"){
cout<<setw(2)<<pro1[j].getname()<<setw(10)<<pro1[j].getprin()<<setw(10)<<pro1[j].getround()<<setw(10)<<pro1[j].getneedtime()<<setw(10)<<pro1[j].getwaittime()<<setw(12)<<pro1[j].getstate()<<endl;
}
else{
cout<<setw(2)<<pro1[j].getname()<<setw(10)<<pro1[j].getprin()<<setw(10)<<pro1[j].getround()<<setw(10)<<pro1[j].getneedtime()<<setw(10)<<pro1[j].getwaittime()<<setw(14)<<pro1[j].getstate()<<endl;
}
}
}
voidadd(intm){//在队列尾巴添加进程
if(m+1>=MAX){
cout<<"就绪队列已满,不能再增加进程!"<<endl;
exit(1);
}
stringst1="ready";
proready[m+1].setstate(st1);
if(flag==1){
proready[m+1].setname();
proready[m+1].setneedtime();
proready[m+1].setround(0);
proready[m+1].setprin(1);
dynamicsort(proready,m+1);//加入动态分配中
}
elseif(flag==2){
proready[m+1].setname();
proready[m+1].setneedtime();
proready[m+1].setround();
proready[m+1].setwaittime(0);
proready[m+1].setprin(m+1);
}
elseif(flag==3){
proready[m+1].setname();
proready[m+1].setround(0);
proready[m+1].setneedtime();
proready[m+1].setwaittime(0);
proready[m+1].setprin(proready[m].getprin()+1);
}
}
voiddynamicrun(PCBproready[],intamount){//动态优先权run
inta1=amount;
inti=1;
intk=0;
stringa,st3="finished";
PCBtemp1;
while(a1>0){
cout<<endl;
cout<<"进程第"<<i<<"次调度"<<endl;
runpro=proready[0];
temp1=proready[0];
/*输出运行时的进程*/
proready[0].setstate("run");
cout<<"**********插入运行队列，进行处理**************"<<endl;
show(proready,1);
for(intj=0;j<a1-1;j++){//对所有的PCB的等待时间加上运行的时间同时修改优先级
proready[j]=proready[j+1];
proready[j].setwaittime(proready[j].getwaittime()+runpro.getneedtime());
proready[j].setprin(1+proready[j].getwaittime()/proready[j].getneedtime());
}
cout<<endl;
Sleep(runpro.getneedtime());
cout<<"**********运行完成，插入完成队列**************"<<endl;
finishpro[k]=temp1;
finishpro[k].setstate(st3);
show(finishpro,k+1);
k++;
cout<<endl;
a1--;
cout<<"是否添加新进程？(Y/N):";
cin>>a;
if(a=="Y"||a=="y"){
add(a1-1);
a1++;
}
if(a1>0){
dynamicsort(proready,a1);
cout<<"******重新分配优先权后的就绪队列*******"<<endl;
show(proready,a1);
}
i++;
}
}
voidFCFS(PCBproready[],intamount){
inta1=amount;
inti=1;
intk=0;
stringa,st3="finished";
PCBtemp1;
while(a1>0){
cout<<"进程第"<<i<<"次调度"<<endl;
runpro=proready[0];
temp1=proready[0];
proready[0].setstate("run");
cout<<"**********插入运行队列，进行处理**************"<<endl;
show(proready,1);
Sleep(runpro.getneedtime());
for(intj=0;j<a1-1;j++){
proready[j]=proready[j+1];
proready[j].setwaittime(proready[j].getwaittime()+runpro.getneedtime());
}
cout<<"**********运行完成，插入完成队列**************"<<endl;
finishpro[k]=temp1;
finishpro[k].setstate(st3);
a1--;
show(finishpro,k+1);
k++;
cout<<endl;
cout<<"**************就绪队列****************"<<endl;
show(proready,a1);
cout<<"是否添加新进程？(Y/N):";
cin>>a;
if(a=="Y"||a=="y"){
add(a1-1);
a1++;
}
i++;
}

}
voidtimeround(PCBproready[],intamount){//时间片轮转调度算法
inti=1;//进程调度次数
floattime;
floatt=0;
inta1=amount;//记录剩余进程
boolt1=true;
stringst2="run",st3="finished";
intflag1=0;
while(t1){
PCBtemp1;
cout<<endl;
cout<<"进程第"<<i<<"次调度"<<endl;
runpro=proready[0];
runpro.setstate(st2);
temp1=proready[0];
proready[0].setstate("run");
cout<<"**********插入运行队列，进行处理**************"<<endl;
show(proready,1);
Sleep(runpro.getround());
for(intj=0;j<a1-1;j++){//前移就绪队列，并修改等待时间
proready[j]=proready[j+1];
proready[j].setwaittime(proready[j].getwaittime()+runpro.getround());
}
time=temp1.getneedtime()-temp1.getround();//减去此次CPU给的时间片，并判断。
if(time<=0){
finishpro[flag1]=runpro;
finishpro[flag1].setneedtime(t);
finishpro[flag1].setstate(st3);
flag1++;
a1--;
if(a1<=0)t1=false;
}
else{
proready[a1-1]=temp1;
proready[a1-1].setwaittime(t);
proready[a1-1].setneedtime(time);
}
if(flag1>0){//如果完成队列不为空，才打印完成队列的情况
cout<<"****************完成队列******************"<<endl;
show(finishpro,flag1);
cout<<endl;
}
if(a1>0){
cout<<"****************就绪队列******************"<<endl;
show(proready,a1);
}else{
cout<<"就绪队列为空！"<<endl;
}

i++;
}
}

};
intmain(intargc,char*argv[])
{
inttest;
prop;
test=p.input();
while(test){
system("cls");
test=p.input();
}
return0;
}

小结：没有用数组来表示运行队列，实际上个人也觉得没必要。因为是模拟的，直接修改了PCB的运行状态就OK了。或者当运行时写个sleep(PCB.getNeedtime())来模拟时间的长短即可！