进程调度模拟程序

核心提示： 我们课程设计，我选择了一个进程调度模拟，进程调度模拟程序，希望大家给看看，多提意见，进程的调用算法我采用的是时间片轮转算法并有所改进，当某个进程从阻塞队列释放后，好久没来发帖子了，#include<iostream.h>#include<stdlib.h>#include<time.h&

　 我们课程设计，我选择了一个进程调度模拟，希望大家给看看，多提意见，好久没来发帖子了。
#include<iostream.h>
#include<stdlib.h>
#include<time.h>
#include<stdio.h>
#include<string.h> const int  MAXCOMMANDLEN =50;　　　　 /////////////////////////////////////////////////////////////////////////////////////
//　　　　　 
//　　　　 PROCESS 
// 
/////////////////////////////////////////////////////////////////////////////////////
class Process　　　　　　　　　　　　  //进程类
{
friend class CPU;
protected:
 static int init_ID;　　 //随机进程ID
　  int ID;　　　　//进程ID
 char runText[MAXCOMMANDLEN];　//进程指令数组
 int ip;　　　　//进程指令指针，保存进程指令执行到的具体位置
 bool ISuseSource;　　 //此进程是否使用资源，ture:使用中  false : 未使用
 bool ISblocked;　　　//此进程是否被阻塞  ture:阻塞  false :未阻塞
 int unitTime;　　　//进程单位被cpu执行时间, 默认 1
 int blockTime;　　　//进程被阻塞时间
public:
 static void RandID();　　//随机生成进程ID
 Process();
 int getID();　　　
 int getIP();　　　
 void setIP(int);　　 
 void Runed();　　　//进程被cpu执行
 int getUnittime();　　 //得到进程单位执行时间
 int getBlcoktime();　　 //得到进程阻塞时间
 void setBlocktime(int);　　//设置进程阻塞时间
 void setUnittime(int);　　//设置进程单位执行时间
 char getResult(int);　　//得到进程执行结果
 char* getRuntext();　　 //得到进程执行的指令
 void setBlockstate(bool);　 //设置阻塞状态
 bool getBlockstate();　　　
 bool getISusesource();　　//得到资源的状态  使用  未使用
 void setISusesource(bool);　 //设置资源的使用状态
}; int Process::init_ID; void Process::RandID()
{
 srand( (unsigned)time( NULL ) );
 init_ID=rand();
}
Process::Process()
{
 ID=init_ID++;　　 
 int commandLen;
 IP=0;  cout<<"Please input the text which process runed by CPU [#command#] :>\ ";
 cin>>runText;
 if( (commandLen=strlen(runText) ) > MAXCOMMANDLEN )
　exit(0);

 
 runText[commandLen]='#';　　 // 指令结束标志 '#'
 runText[commandLen+1]='';
 ISuseSource=false;
 ISblocked=false;
 unitTime=1;
 blockTime=0;
}
void Process::Runed()

int Process::getID()
{
 return ID;
} int Process::getIP()
{
 return IP;
} void Process::setIP(int ip)
bool Process::getISusesource()
{
 return ISuseSource;
} void Process::setISusesource(bool s)
char* Process::getRuntext()
{
 return runText;
} int Process::getUnittime()
{
 return unitTime;
}
int Process::getBlcoktime()
{
 return blockTime;
} void Process::setBlocktime(int BT)
void Process::setUnittime(int UT)
void Process::setBlockstate(bool state)
bool Process::getBlockstate()
{
 return ISblocked;
} char Process::getResult(int k)
{
　return runText[k];
} /////////////////////////////////////////////////////////////////////////////////////
//　　　　　 
//　　　　 SOURCE 
// 
///////////////////////////////////////////////////////////////////////////////////// class Source　　　　//资源类
{
protected:
 int ID;　　　　 //资源 ID
 bool state;　　　　//资源状态 true : 未被进程占有  false : 已被占有
 int pro_ID;　　　　//使用资源的进程id
 Process *pro;　　　 //使用资源的进程指针
 int time;　　　　//进程使用资源的时间
public:
 Source(int);
 bool getState();　　　//得到进程状态
 void setState(bool);　　 //设置进程状态
 void setTime(int);　　　//设置进程使用资源的时间
 void setPro(Process *);　　 //设置使用该资源的进程
 int getID();　　　 //得到资源id
 int getPorID();　　　 //得到使用资源的进程id
 void setProID(int);　　　//设置使用资源的进程id
 void runned();　　　 //资源被cpu调用
}; Source::Source(int id)
void Source::setProID(int id)
void Source::setTime(int t)
void Source::setState(bool s)
bool Source::getState()
{
 return state;
} void Source::setPro(Process *p)
void Source::runned()
{
 if(time>0)
 {
　cout<<"( Source :"<<ID<<")";

　time--;
 }
 if(time<=0)　　　　　//进程使用完资源释放资源，使用资源的时间到
 {
　pro->setISusesource(false);
　int ip=pro->getIP();
　pro->setIP(++ip);
　Source::setState(true);
　cout<<endl<<"The process "<<pro->getID()<<" relase the source!"<<endl;
　pro=NULL;
 }
} /////////////////////////////////////////////////////////////////////////////////////
//　　　　　 
//　　　　 CPU 
// 
///////////////////////////////////////////////////////////////////////////////////// typedef strUCt Block　　 //阻塞队列结构
{
 Process *p_BlockProcess;　 //被阻塞的进程队列
 int index;　　　 //被阻塞的进程在就绪队列中的索引（位置） 
}Block; class CPU　　　 
{
protected:
 Process *p_Process;　　 //进程队列
 Process **pp_Process;　　//进程就绪队列
 Block *blockQueue ;　　//进程阻塞队列
 Source  *p_Source;　　 //资源指针
 int numOfprocess;　　 //进程数量
 int numOfblock;　　　//被阻塞的进程数
 int PC;　　　　//程序计数器
 int allTime;　　　//cpu运行的总时间
public :
 CPU(int); 
 void Run();　　　 //cpu运行进程
 bool _IC(Process&);　　 //虚拟IC,进行进程指令翻译
 void useSource(Process&);　 //进程申请资源
 void blockProcess(Process&);　　　  //阻塞进程
 void releaseBlockPro();　　//释放阻塞进程
 int getAlltime();　　 //得到进程运行的总时间
 void displayPro();　　 //显示进程的基本信息，id,指令,运行时间等
 void blockTimeADD();　　//阻塞时间加1
}; CPU::CPU(int num)
{
　p_Source=new Source(379857);
　numOfprocess=num;
　numOfblock=0;
　allTime=0;
　p_Process=new Process[numOfprocess];
　pp_Process=new Process*[numOfprocess];
　blockQueue=new Block[numOfprocess];
　for(int i=0;i<numOfprocess;i++)
　
} int CPU::getAlltime()
{
 return allTime;
} void CPU::displayPro()
{
 for(int i=0;i<numOfprocess;i++)
 {
　cout<<" Process ID : "<<p_Process[i].getID()<<endl;

　cout<<"　 text of runned :"<<p_Process[i].getRuntext()<<endl;
 }
} void CPU::Run()
{
 int numPro=numOfprocess;  do
 {
　for(int num=0;num < numOfprocess;num++)
　{
　 if(!pp_Process[num])　　  //假如该指针为空，说明该进程不在就绪队列中
　　continue; 　 for(int t=0;t<p_Process[num].getUnittime();t++)
　 {
　　PC=p_Process[num].getIP();
　　if(_IC(p_Process[num]))　　 
　　{
　　 if(t==0)
　　　cout<<"the process ["<<p_Process[num].getID()<<"] runed : ";
　　 if(!p_Process[num].getISusesource())
　　 
　　 else
　　 {
　　　 p_Source->runned();
　　　 if( p_Source->getState() && numOfblock>0 )　　 //释放阻塞进程
　　　 
　　 }
　　}
　　else
　　{
　　 if(!p_Process[num].getBlockstate())
　　 {
　　　numPro--;
　　　　 pp_Process[num]=NULL;
　　　continue; 
　　 }
　　 break;
　　}
　　allTime++;
　　if(numOfblock>0)
　　 blockTimeADD();
　 }//end for t...
　 if( p_Process[num].getUnittime() )
　　p_Process[num].setUnittime(1);
　 cout<<endl;
　}//end for num...  }while(numPro);
} bool CPU::_IC(Process &p)　　　　　　　　　　
{
 //对进程中的指令进行翻译
 char resultRunned;
 
 resultRunned=p.getResult(PC);
 if(resultRunned=='#')
　return false;
 else
 {
　if(resultRunned==' )　　　//申请资源指令
　{
　 PC++;
　 p.setIP(PC);
　 resultRunned=p.getResult(PC);
　 if( resultRunned >='1' && resultRunned <='9' )
　 {
　　if(p_Source->getState())
　　{
　　 //资源未被使用则使用资源
　　 useSource(p);

　　 cout<<"The process "<<p.getID()<<" take up the source!"<<endl;
　　}
　　else
　　{
　　 //资源已被使用则阻塞进程
　　 blockProcess(p);
　　 cout<<"The process "<<p.getID()<<" is blocked !"<<endl;
　　 return false; 　　}
　 }
　 else
　 {
　　//' 后跟的不是数字，则语法错误
　　cout<<"The process ["<<p.getID()<<"] runned fail ! It has been stopped! "<<endl;
　　return false;
　 }
　}  }
　return true;
} void CPU::blockTimeADD()
{
 for(int i=0;i<numOfblock;i++)
 {
　int BT=blockQueue[i].p_BlockProcess->getBlcoktime();
　blockQueue[i].p_BlockProcess->setBlocktime(++BT);
 }
} void CPU::useSource(Process& p)
{
 p.setISusesource(true);
 p_Source->setState(false);
 p_Source->setProID(p.getID());
 p_Source->setTime(p.getResult(PC)-'0');
 p_Source->setPro(&p); } void CPU::blockProcess(Process& p)
{
 int tempIndex=numOfprocess-( Process::init_ID-p.getID() );
 blockQueue[numOfblock].p_BlockProcess=&p;
 blockQueue[numOfblock].index=tempIndex;
 numOfblock++;
 int ip=p.getIP();
 p.setIP(--ip);
 p.setBlockstate(true);
 p.setBlocktime(1);
 p.setUnittime(0);
 pp_Process[tempIndex]=NULL; } void CPU::releaseBlockPro()
{
 //释放阻塞队列的第一个进程，因为它阻塞时间最长
 pp_Process[blockQueue[0].index]=blockQueue[0].p_BlockProcess;
 blockQueue[0].index=-1;
 blockQueue[0].p_BlockProcess->setBlockstate(false);
 blockQueue[0].p_BlockProcess->setUnittime( blockQueue[0].p_BlockProcess->getBlcoktime() );
 blockQueue[0].p_BlockProcess->setBlockstate(0);
 blockQueue[0].p_BlockProcess=NULL;
 numOfblock--;
 
 //阻塞队列中的其他进程向前移动一个位置
 for(int i=0;i<numOfblock;i++)
 
}
/////////////////////////////////////////////////////////////////////////////////////
//　　　　　 
//　　　　The main progress
// 
/////////////////////////////////////////////////////////////////////////////////////
void main()
{
 int num;
 cout<<" ********************************************************"<<endl
　<<endl; 
 cout<<" 　　　　　　 The virtual CPU　  the process runned　　　　　 "<<endl

　<<endl;
 cout<<" *******************************************************"<<endl
　<<endl;
 
 cout<<"initialize the information of processes "<<endl;  cout<<"Please input the number of process [#command#] >\ ";  try
 
 catch(int)
 {
　cout<<"You input the numbers of process is error !"<<endl;
　exit(1);
 }  Process::RandID();　 // 随机生成第一个进程的ID,以后生成的进程ID顺序加1
 CPU virtualCPU(num);　　　　
 
 cout<<"Pocesses runed by CPU "<<endl;
 virtualCPU.Run(); 
 
 cout<<"Processes runned over ! "<<endl;
 cout<<" ********************************************************"<<endl
　<<endl; 
 cout<<" The time which processes runned by CPU : "<<virtualCPU.getAlltime()<<endl
　<<endl;
 virtualCPU.displayPro();
 cout<<" *******************************************************"<<endl
　<<endl;
} 这里没有任何的API调用 只是模拟，我给进程设定了自己的语法，输入一般的字符cpu调用时只是正常输出，假如碰到' 表示该进程要调用系统资源后面必须跟一个数字表示占有的时间，假如资源闲置则占有资源否则阻塞，等资源释放在占有资源。进程的调用算法我采用的是时间片轮转算法并有所改进，当某个进程从阻塞队列释放后，他将把以前因为等待资源而被浪费的时间补回来。
希望大家多提意见