编程实现如下进程调度算法:
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;
}
};
以上就是三种进程调度算法。