进程调度模拟程序

   我们课程设计，我选择了一个进程调度模拟，希望大家给看看，多提意见，好久没来发帖子了。
　　#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调用时只是正常输出，假如碰到' 表示该进程要调用系统资源后面必须跟一个数字表示占有的时间，假如资源闲置则占有资源否则阻塞，等资源释放在占有资源。进程的调用算法我采用的是时间片轮转算法并有所改进，当某个进程从阻塞队列释放后，他将把以前因为等待资源而被浪费的时间补回来。
　　希望大家多提意见