进程调度算法

编程实现如下进程调度算法：

1)时间片轮转调度算法：该算法将所有就绪进程排成一个就绪队列，并设置每隔一个时间间隔即产生一次中断，激活系统中的进程调度程序，完成一次调度。时间片长度在运行时可从键盘输入。
2)多级反馈队列调度算法：该算法设置多个就绪队列，每个队列的优先级是不同的，将不同的进程加入到相应的队列中，每个队列按FCFS调度算法实现。按优先级高低进行进程调度。至少要有三个队列，第i+1队列进程运行的时间片是第i队列的2倍。
3)高响应比优先调度算法：该算法是设定一个动态的优先级，按照这个优先级高低进行进程调度。当调度响应比高的进程运行时，仍然是运行一个时间片，而不是完全结束，刚运行的进程，其以前的等待时间清零。

头文件：

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <string>
#include <fstream>
#include <algorithm>
using namespace std;

PCB数据结构的定义：

struct PCB {
	int process; //进程标识符
	char name;
	int atime;//到达时间
	int stime;//服务时间
	int wtime;//等待时间
	int etime;//完成时间
	double rate;//响应比
};//进程控制块

主程序：
从文件中输入数据将进程初始化，再用三种调度算法分别对其进行调度，注：每次用新的调度算法时都要重新初始化。

int main(){
int n,i;
PCB pcb[100];
ifstream test1(“test.txt”);//从文件中输入
test1>>n;
for(i=0;i<n;i++){
test1>>pcb[i].process>>pcb[i].name>>pcb[i].atime>>pcb[i].stime;
}

cout<<"初始进程情况"<<endl;
cout<<"标识符 "<<"进程名 "<<"到达时间 "<<"服务时间 "<<endl;
Disp(pcb,n);
for(i=0;i<n;i++){//初始化pcb
	pcb[i].wtime=-1;
	pcb[i].etime=-1;
	pcb[i].rate=-1;
}


cout<<"使用轮转调度算法"<<endl;
cout<<"标识符 "<<"进程名 "<<"到达时间 "<<"服务时间 "<<"结束时间"<<endl;
RR rr;
rr.round(pcb,n);
test1.close();

ifstream test2("test.txt");//从文件中输入
test2>>n;
for(i=0;i<n;i++){
	test2>>pcb[i].process>>pcb[i].name>>pcb[i].atime>>pcb[i].stime;
}
	for(i=0;i<n;i++){//初始化pcb
	pcb[i].wtime=-1;
	pcb[i].etime=-1;
	pcb[i].rate=-1;
}

cout<<"使用多级反馈队列调度算法"<<endl;
cout<<"标识符 "<<"进程名 "<<"到达时间 "<<"服务时间 "<<"结束时间"<<endl;
MFQ mfq;
mfq.mqueue(pcb,n);
test2.close();

ifstream test3("test.txt");//从文件中输入
test3>>n;
for(i=0;i<n;i++){
	test3>>pcb[i].process>>pcb[i].name>>pcb[i].atime>>pcb[i].stime;
}
for(i=0;i<n;i++){//初始化pcb
	pcb[i].wtime=-1;
	pcb[i].etime=-1;
	pcb[i].rate=-1;
}

cout<<"使用高响应比调度算法"<<endl;
cout<<"标识符 "<<"进程名 "<<"到达时间 "<<"服务时间 "<<"等待时间 "<<"结束时间"<<endl;
HRRN hrrn;
hrrn.highrate(pcb,n);
test3.close();

return 0;

}

显示初始化信息的函数：
/显示初始化信息/
void Disp(PCB pcb[],int n){
int i;
for(i=0;i<n;i++){
cout<<pcb[i].process<<" “<<pcb[i].name<<” “<<pcb[i].atime<<” "<<pcb[i].stime<<endl;
}
cout<<endl;
}

/时间片轮转调度算法/
class RR{
private:
int time; //现在的时间
public:

/*时间初始化*/
RR(){
	time=0;
}

/*运行进程*/
void act(PCB &pcb){
	pcb.stime=pcb.stime-1;
}

/*时间片轮转*/
void round(PCB pcb[],int n){
	//disp(pcb,n);
	int i,flag=1,count=0;
	while(flag){//运行知道所有的进程都完成
	for(i=0;i<n;i++){
		if(pcb[i].stime>=1){//如果还有时间，执行进程
			count=1;
			act(pcb[i]);
			time++;
			if(pcb[i].stime==0)//运行结束，当前时间为结束时间
				pcb[i].etime=time;		
		}
		disp(pcb,n);
	}
		if(count==0)
			flag=0;
		count=0;
	}
}

/*显示进程信息*/
void disp(PCB pcb[],int n){
	int i;
	for(i=0;i<n;i++){
		cout<<pcb[i].process<<" "<<pcb[i].name<<" "<<pcb[i].atime<<" ";
		cout<<pcb[i].stime<<" "<<pcb[i].etime<<endl;
	}
	cout<<endl;
}

};

队列的定义和常用方法：
class Queue{//队列的类
public:
int a[100];//存进程的序号
int front;//头指针
int rear;//尾指针

/*队列初始化*/
Queue(){
	front=0;
	rear=0;
}

/*进队*/
void EnQueue(int i){
	a[rear]=i;
	rear++;
}

/*出队*/
void DeQueue(int &i){
	i=a[front];
	front++;
}

/*判断队列是否为空*/
int isempty(){
	if(front==rear)
		return 1;
	else
		return 0;
}

};

/多级反馈队列调度算法/
class MFQ{
private:
int time; //当前时间
Queue q1; //一级队列
Queue q2; //二级队列
Queue q3; //三级队列
public:
MFQ(){
time=0;
}

/*运行进程*/
void act(PCB &pcb){
	time+=pcb.stime;
	pcb.stime=0;
	pcb.etime=time;
}

/*多级反馈队列调度*/
void mqueue(PCB pcb[],int n){
	inqueue(pcb,n);
	FCFS(q1,pcb,n);
	FCFS(q2,pcb,n);
	FCFS(q3,pcb,n);
}

/*进程进入队列*/
void inqueue(PCB pcb[],int n){
	int i;
	//分为三级队列，后一队列优先级是前一个两倍
	for(i=0;i<n;i++){
		if(pcb[i].stime<=1)
			q1.EnQueue(i);
		else if(pcb[i].stime<=2)
			q2.EnQueue(i);
		else if(pcb[i].stime<=4)
			q3.EnQueue(i);
	}
}

/*先来先服务算法*/
void FCFS(Queue q,PCB pcb[],int n){
	int i;
	for(i=q.front;i<q.rear;i++){
		act(pcb[q.a[i]]);
		disp(pcb,n);
	}
}
/*显示进程信息*/
void disp(PCB pcb[],int n){
	int i;
	for(i=0;i<n;i++){
		cout<<pcb[i].process<<" "<<pcb[i].name<<" "<<pcb[i].atime<<" ";
		cout<<pcb[i].stime<<" "<<pcb[i].etime<<endl;
	}
	cout<<endl;
}

};

/高响应比调度算法/
class HRRN{
private:
int time;//现在时间
int s[10];//存现在优先级的
public:

/*初始化现在的时间*/
HRRN(){
	time=0;
}

/*运行进程*/
void act(PCB pcb[],int i,int n){
	int k;
	pcb[i].wtime=0;//现在进程等待时间为0
	pcb[i].stime--;//服务时间减少
	for(k=0;k<n;k++){//其余所有队列等待时间加1
		if(k==i)
			continue;
		if(pcb[i].atime>=time)
			pcb[i].wtime++;
	}
	if(pcb[i].stime==0)//判断是否结束
		pcb[i].etime=time;
}

/*计算响应比*/
void crate(PCB pcb[],int n){
	int i;
	for(i=0;i<n;i++){
		pcb[i].rate=((double)pcb[i].wtime)/pcb[i].stime;
	}
}

/*按响应比排序*/
void Sort(PCB pcb[],int n){
	int i,j;
	PCB p;
	//按响应从大到到小排序
	for(i=0;i<n;i++){
		for(j=1;j<n-i;j++){
			if(pcb[j-1].rate>pcb[j].rate){
				p=pcb[j-1];
				pcb[j-1]=pcb[j];
				pcb[j]=p;
			}
		}
	}	
}

/*高响应比调度*/
void highrate(PCB pcb[],int n){
	int i,j,flag=1;
	/*初始化等待时间*/
	for(i=0;i<n;i++)
		pcb[i].wtime=0;
	while(flag){//直到所有进程都结束时退出
	for(i=0;i<n;i++){
		if(pcb[i].stime>=1){
			act(pcb,i,n);
			time++;
			disp(pcb,n);
			crate(pcb,n);
			Sort(pcb,n);//重新给进程排序
			break;
		}		
	}
		//判断全部进程是否结束
		for(j=0;j<n;j++){
			if(pcb[j].etime==-1){
				flag=1;
				break;
			}
			else
				flag=0;
		}	
	}
}

	/*显示进程信息*/
	void disp(PCB pcb[],int n){
		int i;
		for(i=0;i<n;i++){
			cout<<pcb[i].process<<" "<<pcb[i].name<<" "<<pcb[i].atime<<" ";
			cout<<pcb[i].stime<<" "<<pcb[i].wtime<<" "<<pcb[i].etime<<endl;
		}
		cout<<endl;
	}
};

以上就是三种进程调度算法。