操作系统进程调度算法

这里先说明，进程调度算法有很多，这里实现的调度算法有先来先服务、短进程优先、高响应比优先、时间片轮转算法。此外还有一个多级反馈队列算法，因为这个算法比较复杂，之后再分析。

下面是我针对各个调度算法的实现的认识。

一、先来先服务算法

 
这个算法相比而言还是十分简单的，我在实现时用到了一个比较低级的队列，队列的长度是进程数，队头与队尾指针均小于进程数，所以我说这是一个比较低级的队列，毕竟这个队列的头尾指针最大只能到进程数。

 
设置一个全局时间，每循环一次，时间加一，在循环内部判断是否有进程到达，有进程到达就把进程标号，也就是下标送入队列，此外，循环内部还有判断进程是否执行完毕的比较，当进程的服务时间加上之前进程的服务时间与全局时间相等，说明这个进程执行结束。记录数据即可，下面是实现的主要代码：

void FCFS()

{

int finish[number],cost[number]; //完成时间，周转时间

int work[number]; //等待队列 

int tou= 0,wei = 0;

int t=0;

int i;

show();

time = 0; 

printf("\n\n");

while(tou!=wei||tou == 0){

for(i = 0;i < number;i ){

if(time == arrive[i]){

work[tou] = i;

tou ;

printf("\t%d 进程%c进入内存\n\n",time,course[i]);

if(time == 0)printf("\t%d 进程%c开始执行\n\n",time,course[i]);

break;

}

}

if(serve[work[wei]] t==time){

printf("\t%d 进程%c执行完毕。\n\n",time,course[work[wei]]);

finish[work[wei]] = time;

t =serve[work[wei]];

wei ;

if(wei

printf("\t%d 进程%c开始执行\n\n",time,course[work[wei]]);

}

time ;

}

prin(finish,cost);

}

二、短进程优先算法

 
这个算法最关键的是在进程进入等待队伍以后要实时找出最短服务时间，依旧是一个循环体中，全局时间每循环一次加一，循环开始依旧是判断进程是否到达，到达后，把用来标志进程是否到达的数组中标记，然后是，第一个到达的进程肯定是无条件执行的，当第一个进程执行完之后，记录时间，并把用来标记进程是否执行过的数组中标记，然后就是在已经到达的且没有执行的进程中找出最短服务时间的进程，执行即可。代码：

void SPF(){

int finish[number],cost[number]; //完成时间，周转时间

int work[number]; //到达队列

int frog[number]; //标志某进程是否进入等待队列

int t=0,min = 100; // t 用来记录已经过去的时间
，min记录已经进入执行队列的最短服务时间

int i,k=0; //k记录最短服务时间的进程下标序号

int n = number;

int a=0;float b=0;

show();

time = 0;

printf("\n\n");

for(i = 0;i < number;i ) {frog[i] = 0;work[i] = 0;}

while(n!=0){

for(i = 0;i < number;i ){ //首先找出当前time下到达的进程

if(time == arrive[i]){

work[i] = 1;

printf("\t%d 进程%c进入内存\n\n",time,course[i]);

if(time == 0)printf("\t%d 进程%c开始执行\n\n",time,course[i]);

break;

}

}

if(serve[k] t==time){

finish[k] = time;

frog[k] = 1;

t =serve[k];

n--;

min=100;

printf("\t%d 进程%c执行完毕。\n\n",time,course[k]);

for(i = 0;i < number;i ){ //找出最短服务时间的进程

if(frog[i] != 1&&serve[i] < min&&work[i] ==
1){ //该进程已经到达，且服务时间是最短的

min = serve[i];

k = i;

}

}

if(n>0)

printf("\t%d 进程%c开始执行\n\n",time,course[k]);

}

time ;

}

prin(finish,cost);

}

三、高响应比优先算法

 
我只能说，这个算法跟短进程优先算法几乎是一模一样，只是把比较哪个进程服务时间最短变成了哪个进程响应比（即等待时间加上服务时间的和与服务时间的比值）是最大的。废话不多说，代码：

void HRRN(){

int finish[number],cost[number]; //完成时间，周转时间

int work[number]; //到达队列

int frog[number]; //标志是否完成

float right[number]; //权值

float max = 0;

int t=0; // t 用来记录已经过去的时间

int i,k=0; //k记录最短服务时间的进程下标序号

int n = number;

int a=0;float b=0;

show();

time = 0;

printf("\n\n");

for(i = 0;i < number;i ) {frog[i] = 0;work[i] = 0;}

while(n!=0){

for(i = 0;i < number;i ){ //首先找出当前time下到达的进程

if(time == arrive[i]){

work[i] = 1;

printf("\t%d 进程%c进入内存\n\n",time,course[i]);

if(time == 0)printf("\t%d 进程%c开始执行\n\n",time,course[i]);

break;

}

}

if(serve[k] t==time){

finish[k] = time;

frog[k] = 1;

t =serve[k];

n--;

printf("\t%d 进程%c执行完毕。\n\n",time,course[k]);

max = 0;

for(i = 0;i < number;i ){

if(frog[i] != 1&&work[i] == 1){ //到达的进程

right[i] =
(((time-arrive[i]) serve[i])/(float)serve[i]);

if(max < right[i]){

max = right[i];

k = i; 

}

}

}

if(n>0)

printf("\t%d 进程%c开始执行\n\n",time,course[k]);

}

time ;

}

prin(finish,cost);

}

四、时间片轮转算法

 
相比前三种方法，时间片轮转还有有那么些许不同的，前三种算法都属于非抢占式的调度方式，只要进程得到CPU资源，就会执行完，然后才会交出CPU，而时间片轮转则是抢占的，只要执行完时间片，就让出CPU，进入等待队列，等待下次执行，如果在一个时间片内进程执行完毕，则重置时间片，开始队列的下一个进程。

 
这里需要使用一个队列，来动态的调整进程的执行顺序，当然，依旧要先判断进程是否到达队列，然后，首先判断时间片的状态，如果时间片执行完毕，则重置时间片，同时把之前执行的进程，也就是先前出队的进程重新放入队尾，同时队头、队尾指针右移，如果时间片的还处于没有执行完的状态，则领当前执行的进程的执行，也就是减一，时间片同时减一。之后就是全局时间加一操作，紧接着，是判断正在执行的进程是否是执行完毕的，执行完毕，把进程的状态改变，同时重置时间片。为什么要在这之前把全局时间加一，是因为我们最后对进城执行情况的检查是基于当前的一个单位的时间已经执行完成的情况下进行的，所以要把这个进程状态的判断放在全局时间改变的后面。下面是代码：

void RR(){

int piece,p;//时间片 

int finish[number],cost[number]; //完成时间，周转时间

int work[number],frog[number];
//到达,是否执行完毕 

int ready[number],h = 0,e = 0; //就绪队列，头，尾

int ser[number]; //服务时间 

int n = number;

int i,c,j;

time = 0;

show();

for(i = 0;i < number;i ){finish[i] = 0;cost[i] =
0;work[i] = -1;frog[i] = 0;ready[i] = -1;ser[i] = serve[i]; }

printf("\n时间片长度：");scanf("%d",&piece);

p = piece;

while(n != 0){

for(i = 0;i < number;i ){ //首先找出当前time下到达的进程

if(time == arrive[i]){

work[i] = 1;

ready[h%number] = i;

h ;

printf("\t%d 进程%c进入内存\n\n",time,course[i]);

break;

}

}

if(p == 0){

ready[h%number] = ready[e%number];

h ;

e ;

printf("\t%d 进程%c暂停执行\n\n",time,course[c]);

p = piece;

}

c = ready[e%number];

if(p > 0){

if(p == piece)printf("\t%d
进程%c开始执行\n\n",time,course[c]);

ser[c]--;

p--;

}

time ;

if(ser[c] == 0){

finish[c] = time;

n--;

e ;

frog[c] = 1;

printf("\t%d 进程%c执行完毕。\n\n",time,course[c]);

p = piece;

}

}

prin(finish,cost);

}