1.cpp

先近先出

#include<stdio.h> 
#include <dos.h>
#include<string.h>
#include<stdlib.h>
#include<conio.h> 
#include<iostream.h> 
const int MAX=100; //定义最大进程数 
struct PCB //定义进程结构体
{
	char name[20];//进程名
	int  stime;//进程启动时间
	int  ltime;//进程cpu时间
	int  IOstime;//I/O的开始时间
	int  IOltime;//I/O的持续时间
	int  right;//优先级
	char  state;//进程状态
}pcbs[MAX];
int round=2;
int t=0;//计时器
int count=0;//记录进程总数
int complete=0;//已完成的进程数
int time=0;//系统时间
int unstarthead=0;//未开始队列的队头
int ready[MAX];//就绪队列
int readynum=0;//就绪队列中的进程个数
int wait[MAX];//等待队列
int waitnum;//等待队列中的进程个数
int run=-1;//没有进程在运行

//读数据函数 
int readData()
{ 
 FILE *fp; 
 char fname[20]; 
 cout<<"请输入进程流文件名:"; 
 cin>>fname; 
 if((fp=fopen(fname,"r"))==NULL)
 {cout<<"错误,文件打不开,请检查文件名."<<endl;}
 else 
 {while(!feof(fp))
    {fscanf(fp,"%s %d,%d,%d,%d,%d",pcbs[count].name,&pcbs[count].stime,&pcbs[count].ltime,&pcbs[count].IOstime,&pcbs[count].IOltime,&pcbs[count].right); 
     count++;
    }
  cout<<endl<<"*******************************************************"<<endl;
  cout<<"输出所读入的数据:"<<endl;
  cout<<"  name stime ltime IOstime IOltime right"<<endl;
  for(int i=0;i<count;i++)
  {cout<<"  "<<pcbs[i].name<<"   "<<pcbs[i].stime<<"     "<<pcbs[i].ltime<<"      "<<pcbs[i].IOstime<<"       "<<pcbs[i].IOltime<<"      "<<pcbs[i].right<<endl;}     
  return(1); 
 }
 return(0); 
}
//初始化函数，让进程按开始时间先后排列      
void init()
{
	int i,j;
	for(i=0;i<count;i++)
	{
		for(j=0;j<count-i-1;j++)
		{
			if(pcbs[j].stime>pcbs[j+1].stime)
			{
				pcbs[-1]=pcbs[j];
				pcbs[j]=pcbs[j+1];
				pcbs[j+1]=pcbs[-1];
			}
		}
	}	
}
//将进程投入就绪态
void inready(int i)
{
	ready[readynum]=i;
	readynum++;
}
//检查未开始队列中是否有进程可进入就绪态
void checkstart()
{
	while(unstarthead<count&&pcbs[unstarthead].stime==time)//未开始队列不空且进程的开始时间与系统时间一致
	{
		inready(unstarthead);//将进程调入就绪态
		unstarthead++;//队头后移
	}
}
//检查等待队列中是否有进程可进入就绪态
void checkwait()
{
	for(int i=0;i<waitnum;i++)
	{
		if(--pcbs[wait[i]].IOltime==0)//队列中I/O等待时间为零时
		{
			inready(wait[i]);//该进程调入就绪队列
			waitnum--;
			for(int j=i;j<waitnum;j++)
			{
				wait[j]=wait[j+1];
			}
			i--;
		}
		
	}
}
//从就绪队列中调出进程
void outready()
{
	if(readynum>0)//如果就绪队列不空，将第一个进程投入运行
	{
		run=ready[0];
		readynum--;
		for(int i=0;i<readynum;i++)
		{
			ready[i]=ready[i+1];//队列向前移一个单位
		}
	}
	else if(readynum<=0)
		run=-1;
}
//FIFO进程调度算法
void checkrun1()//检查运行中的进程是否发生状态转换
{
	if(run==-1)//没有进程正在运行，则从就绪队列中调入
	{
		outready();
	}
	else//有进程运行中
	{
		if(--pcbs[run].ltime==0)//进程运行完调入完成队列
		{
			complete++;
			run=-1;//没有进程运行
			outready();//从就绪队列调入
		}
		else if(--pcbs[run].IOstime==0)//I/O时间到调入等待队列
		{
			wait[waitnum]=run;
			waitnum++;
			outready();//没有进程正在运行，则从就绪队列中调入
		}
	}
}
//优先级算法
void init2()//初始化就绪队列并按优先级从高到低排列
{	if(readynum>0)

  {int k,j,temp;
	   for(k=0;k<readynum;k++)
	   {
		for(j=0;j<readynum-k-1;j++)
		{
			if(pcbs[ready[j]].right<pcbs[ready[j+1]].right)
			{
				temp=ready[j];
				ready[j]=ready[j+1];
				ready[j+1]=temp;
			}
		}
	   }	
}
}
void checkrun2()//检查运行中的进程是否发生状态转换
{
	if(run==-1)//没有进程正在运行，则从就绪队列中调入
	{
		outready();
	}
	else//有进程运行中
	{
       if(--pcbs[run].ltime==0)//进程运行完调入完成队列
		{
			complete++;
			run=-1;//没有进程运行
			outready();//从就绪队列调入
		}
	  else if(--pcbs[run].IOstime==0)//I/O时间到调入等待队列
	  {     pcbs[run].right--;
			wait[waitnum]=run;
			waitnum++;
			outready();//没有进程正在运行，则从就绪队列中调入
		}
	 else if(readynum!=0)
	 {if(--pcbs[run].right<pcbs[ready[0]].right)//如果当前进程的优先级比就绪队首的低
	 {
		 inready(run);//将运行的进程调入就绪队列
		 run=-1;//没有进程运行
	     outready();//从就绪队列调入
	 }
	}
	}
}
//时间片轮转算
void checkrun3() //检查运行中的进程是否发生状态转换
{if(run==-1)//没有进程正在运行，则从就绪队列中调入
	{
		outready();
	}
else
	{
        if(--pcbs[run].ltime==0)//进程运行完调入完成队列
		{   t=0;
			complete++;
			run=-1;//没有进程运行
			outready();//从就绪队列调入
		}
		if(--pcbs[run].IOstime==0)//I/O时间到调入等待队列
		{   t=0;
			wait[waitnum]=run;
			waitnum++;
			outready();//没有进程正在运行，则从就绪队列中调入
		}
		else if(++t==round)
        { t=0;
		 inready(run);
		 outready();
		}
	}
}

//显示提示函数
void version1()
{
 cout<<"                       进  程  调  度  课  程  设  计"<<endl;
 cout<<"                       ++++++++++++++++++++++++++++++"<<endl;
 cout<<"                          (FIFO,优先数,时间片轮转)"<<endl;
 cout<<"                          ------------------------"<<endl;
}
//显示输出结果
void version2()
{
	printf("\n*********** time: %d ************\n",time);
	if(run!=-1)
		printf("On running: %s",pcbs[run].name);
	printf("\nOn ready: ");
	for(int i=0;i<readynum;i++)
	{
		printf("%s  ",pcbs[ready[i]].name);
	}
	printf("\nOn waiting: ");
	for(int j=0;j<waitnum;j++)
	{
		printf("%s  ",pcbs[wait[j]].name);
	}
}
//显示版权信息函数 
void version3() 
{ 
cout<<endl<<endl;

cout<<"             * * * * * * * * * * * * * * * * * * * * * * * * * *"<<endl; 
cout<<"             *　　　 　　   辛苦工作人员名单　 　 　  　 *"<<endl; 
cout<<"             * * * * * * * * * * * * * * * * * * * * * * * * * *"<<endl; 
cout<<"             *　 　             　　　     *"<<endl; 
cout<<"             *　　　      　　　　　　　                       *"<<endl; 
cout<<"             *　　　           　　　　　      *"<<endl; 
cout<<"             * * * * * * * * * * * * * * * * * * * * * * * * * *"<<endl; 
cout<<endl<<endl; 
} 
void FIFO()//先级先出调度算法
{   
	init();//初始化，按开始时间排序
    while(complete!=count)
	{
		checkstart();//检查是否有进程要开始
		checkwait();//检查等待队列中的进程是否进入就绪队列
		checkrun1();//检查运行中的进程是否发生状态转换
        version2();
		time++;
	}
  version3();
}
void privilege()//优先级调度算法
{  init();//初始化，按开始时间排序

     while(complete!=count)
	{
		checkstart();//检查是否有进程要开始
		checkwait();//检查等待队列中的进程是否进入就绪队列
		init2();//初始化就绪队列，按优先级高低排列
		checkrun2();//检查运行中的进程是否发生状态转换
        version2();
		time++;
	}
  version3();
}
void roundrun()//时间片轮转调度算法
{
 init();//初始化，按时间开始先后排序
 while(complete!=count)
 { 
   checkstart();//检查是否有进程要开始
   checkwait();//检查等待队列中的进程是否进入就绪队列
   
   checkrun3();//检查运行中的进程是否发生状态转换
   version2();   
   time++;
 }
version3();
}
void main()//主函数 
{ 
int flag; 
version1(); 
init(); 
flag=readData();
cout<<""<<endl;
cout<<"(F－FIFO算法,P－优先数算法,R-时间片轮转),请选择(F/P/R)："<<endl;
if(flag==1)
{
  char c;	
  scanf("%c",&c);
  switch(c)
  { case 'F':FIFO();break;
    case 'P':privilege();break;
	case 'R':roundrun();break;
   default:printf("error");
  }
} 
}