处理器调度-----C语言解决方法

题目如下：

设计一个按优先数调度算法实现处理器调度的程序。

[提示]：

(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

进程名

指针

要求运行时间

优先数

状态

其中，进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 为了调度方便，把五个进程按给定的优先数从大到小连成队列。用一单元指出队首进程，用指针指出队列的连接情况。例：

 

  队首标志

         K2    

K1	P1	K2	P2	K3	P3	K4	P4	K5	P5
	0		K4		K5		K3		K1
	2		3		1		2		4
	1		5		3		4		2
	R		R		R		R		R
	PCB1		PCB2		PCB3		PCB4		PCB5

 

(4) 处理器调度总是选队首进程运行。采用动态改变优先数的办法，进程每运行一次优先数就减“1”。由于本实习是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：

优先数-1

要求运行时间-1

来模拟进程的一次运行。

提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行结束。在这里省去了这些工作。

(5) 进程运行一次后，若要求运行时间¹0，则再将它加入队列（按优先数大小插入，且置队首标志）；若要求运行时间=0，则把它的状态修改成“结束”（E），且退出队列。

(6) 若“就绪”状态的进程队列不为空，则重复上面（4）和（5）的步骤，直到所有进程都成为“结束”状态。

(7) 在所设计的程序中应有显示或打印语句，能显示或打印每次被选中进程的进程名以及运行一次后进程队列的变化。

(8) 为五个进程任意确定一组“优先数”和“要求运行时间”，启动所设计的处理器调度程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。

附加：在优先级降为0时，而进程还没运行完时，按运行时间最长的先运算

编译环境：Dev-C++

C语言程序

//main.c

#include <stdio.h>
#include"string.h"
#include"Chuliqi.h"

#define num 5//假设系统中进程个数为5
 
int main() {
    initiate();//初始化进程 
    run();//优先数调度算法
    return 0;
}

//Chuliqi.h

#include <math.h>
#define num 5

struct PCB
{
    char ID;//进程名
    int runtime;//运行时间
    int pri;//优先数
    char state;//状态，R-就绪，E-结束，F-正在运行 
 };
struct PCB A[num];//定义进程控制块数组

//随机数函数
int random(int m)
{
    return rand()%m;
} 

//初始化进程
void initiate()
{
    int i;//i为进程编号
    for(i=0;i<num;i++)
    {
        //为每个进程给出优先级和运行时间 
        A[i].pri=random(20);
        A[i].runtime=random(50);
        printf("请输入PCB[%d]的进程名:\n",i+1);
        scanf("%s",&A[i].ID);
        A[i].state='R';//初始状态都设为就绪 
        getchar();
     } 
 } 
 
//找出最大优先级进程(返回值为最大优先数进程编号) 
int max_pri()
{
    int max=-1;//max为最大优先数    
    int i;
    int m;//m为最大进程的编号
    for(i=0;i<num;i++)
    {
        if(A[i].state=='F') return -1;//正在运行
        else if((max<A[i].pri)&&(A[i].state=='R')) 
        {
            max=A[i].pri;    m=i; 
        }
    } 
    //确保最大优先数进程还没结束运行 
    if(A[m].state=='E')    return -1;
    else     return m;
 }
 
//显示函数 
void show()
{
    int i;
    printf("\nID runtime pri state\n");
    printf("------------------------------\n");
    for(i=0;i<num;i++)
    {
        printf("%s%6d%6d\t\t%s\n",&A[i].ID,A[i].runtime,A[i].pri,&A[i].state);
    }
    printf("------------------------------\n");
 } 

//优先数调度算法
void run()
{
    int i,j,m=0;
    int max_time=-1;
    int t=0;//t为程序总运行次数 
    for(i=0;i<num;i++)
        t+=A[i].runtime; 
        
    printf("\n初始时各进程信息:\n");
    show();
    getchar();
    
    for(j=0;j<t;j++)
    {
        //当程序正在运行时('F'为运行态) 
        while(max_pri()!=-1)
        {
            if(A[max_pri()].pri!=0)    A[max_pri()].state='F';
            else{//当优先级降为0，进程还没运行完时
                for(i=0;i<num;i++)
                    if(max_time<A[i].runtime)    {max_time=A[i].runtime;m=i;}
                max_time=-1;
                A[m].state='F';
            }
        }
        
        //判断程序状态(对优先数和运行时间操作) 
        for(i=0;i<num;i++)
        {
            if(A[i].state=='F')    
            {
                if(A[i].pri>0)    {A[i].pri--;}    
                A[i].runtime--;
            }
            if(A[i].runtime==0) A[i].state='E';
            else A[i].state='R';
        } 
        show();
        getchar();
    }    
 } 

实验结果：