第三章

一、目的和要求

1. 实验目的

用高级语言完成一个进程调度程序，以加深对进程的概念及进程调度算法的理解。

2．实验要求

设计一个有 N个进程并发执行的进程调度模拟程序。

进程调度算法：采用最高优先级优先的调度算法（即把处理机分配给优先级最高的进程）和先来先服务（若优先级相同）算法。

(1).  每个进程有一个进程控制块（PCB）表示。进程控制块包含如下信息：进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。

(2).  进程的优先级及需要的运行时间可以事先人为地指定，进程的运行时间以时间片为单位进行计算。

(3).  每个进程的状态可以是就绪 r（ready）、运行R（Running）、或完成F（Finished）三种状态之一。

(4).  就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。

(5).  如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待调度。

(6).  每进行一次调度程序都打印一次运行进程、就绪队列中各个进程的 PCB，以便进行检查。 　　

(7).  重复以上过程，直到所要进程都完成为止。

二、实验内容

编写并调试一个模拟的进程调度程序，采用“最高优先数优先”调度算法对N（N不小于5）个进程进行调度。

三、实验方法、步骤及结果测试

1.    源程序名：动态优先数简化.cpp，可执行程序名：动态优先数简化.exe

2.    原理分析

（1）“最高优先级优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。动态优先数是指进程的优先数在创建进程时可以给定一个初始值，并且可以按一定规则修改优先数。例如：在进程获得一次CPU后就将其优先数减少1，并且进程等待的时间超过某一时限（2个时间片时间）时增加其优先数等。

（2）定义进程控制块的结构体和程序工作时间的结构体，pcb可以包含以下信息：进程控制块包含如下信息：进程名、优先级、到达时间、需要运行时间、已用CPU时间、进程状态等等。

（3）通过构造进程输入input()，进程运行结果输出output()，disp(),以及使整个程序正常运行的函数块等，通过主函数调用方法函数的想法来实现进程调度模拟。

（4）在对进程控制块的访问和调用通过链表指针的形式，在进程控制块输入后，会显示输入的内容，并把每一个作业运行的状态都能在程序中体现出来。

3.      主要程序段及其解释：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <windows.h>
#define NUM 3
struct pcb
{
char name[5];//进程名
int value;//优先数
int m_time;//需要运行时间
int r_time;//已运行时间
char condition[100];//状态
struct pcb *next;
};
struct pcb PCB[NUM],center;
struct pcb *headc;
int count = NUM;
void Initialize()/*初始化*/
{
int i;
for(i=0;i<NUM;i++)
{
printf("请输入第%d个进程名:
",i+1);
scanf("%s",&PCB[i].name);
printf("请输入第%d个进程的需要运行时间:
",i+1);
scanf("%d",&PCB[i].m_time);
printf("请输入第%d个进程的优先数:
",i+1);
scanf("%d",&PCB[i].value);
PCB[i].r_time=0;
strcpy(PCB[i].condition,"Ready");
}
}
void valueChange(struct pcb *p)
{
int i = 0;
while(p!=NULL)
{
PCB[i] = *p;
p=p->next;
i++;
}
count = i;
}
struct pcb* Sort()/*按优先级排序(高到低)*/
{
struct pcb *head,*q,*p1;
int i,j;
for(i=0;i<count;i++)
{
for(j=i+1;j<count;j++)
{
if(PCB[i].value<PCB[j].value)
{
center=PCB[i];
PCB[i]=PCB[j];
PCB[j]=center;
}
}
}
head=(struct pcb*)malloc(sizeof(struct pcb));
p1=head;
for(i=0;i<count;i++)
{
q=(struct pcb*)malloc(sizeof(struct pcb));
strcpy(q->name,PCB[i].name);
strcpy(q->condition,PCB[i].condition);
q->m_time=PCB[i].m_time;
q->r_time=PCB[i].r_time;
q->value=PCB[i].value;
q->next=NULL;
p1->next=q;
p1=q;
}
return head;
//p=head->next;
}
void PrintReady()
{
struct pcb* p;
p=headc->next;
if(p!=NULL)
{
printf("就绪队列信息:
 ");
printf("进程名	优先数	已运行时间	还需运行时间	进程状态
");
while(p!=NULL)
{
printf("%s	%d	%d		%d 		%s
",p->name,p->value,p->r_time,p->m_time,p->condition);
p=p->next;
}
}
}


int Rule()
{
struct pcb* p;
p=headc->next;
while(1)
{
if(p->r_time==p->m_time)
{
strcpy(p->condition,"Run");
printf("正在运行的进程为:%s
",p->name);
printf("进程名	优先数	已运行时间	还需运行时间	进程状态
");
printf("%s	%d	%d		%d 		%s
",p->name,p->value,p->r_time,p->m_time,p->condition);
strcpy(p->condition,"Finish");
p=p->next;
if(p==NULL)
{
printf("所有进程结束!
");
return 0;
}
}
else
{
printf("正在运行的进程为:%s
",p->name);
// printf("正在运行的进程的状态为:
");
strcpy(p->condition,"Run");
printf("进程名	优先数	已运行时间	还需运行时间	进程状态
");
printf("%s	%d	%d		%d 		%s
",p->name,p->value,p->r_time,p->m_time,p->condition);
Sleep(2000);
if(p->next==NULL)
{
while(1)
{
p->value--;
p->r_time++;
if(p->r_time!=p->m_time+1)
{
strcpy(p->condition,"Run");
printf("正在运行的进程为:%s
",p->name);
printf("进程名	优先数	已运行时间	还需运行时间	进程状态
");
printf("%s	%d	%d		%d 		%s
",p->name,p->value,p->r_time,p->m_time,p->condition);
Sleep(2000);
}
else
{
printf("所有进程结束!
");
return 0;
}


}
}
else if(p->value<p->next->value&&p->next!=NULL)
{
valueChange(p);
p = Sort()->next;
}
}
p->value--;
p->r_time++;
}
return 0;
}
void main()
{
Initialize();
// p2=(struct pcb *)malloc(sizeof(struct pcb));
headc = Sort();
PrintReady();
Rule();
}

四、实验总结

这个实验是对作业调度程序的补充，实验过程中需要对每个进程的执行过程的先后顺序的结果进行显示，需要考虑每个进程的优先级，即先进行排序，然后才能执行进程的调度。