动态高优先权优先

姓名： 学号： 地点： 指导老师： 专业班级：

实验名称：动态高优先权优先一、实验内容：

1、 实验内容：

2、 模拟实现动态高优先权优先（若数值越大优先权越高，每运行一个时间单位优先权-n，

若数值越小优先权越高，没运行一个时间单位优先权+n），具体如下：

3、 设置作业体：作业名，作业的到达时间，服务时间，初始优先权，作业状态（W——等

待,R——运行,F——完成），作业间的链接指针

4、 作业初始化：由用户输入作业名、服务时间、初始优先权进行初始化，同时，初始化作

业的状态为W。

5、 显示函数：在作业调度前、调度中和调度后进行显示。

6、 排序函数：对就绪状态的作业按照优先权排序。优先权相同时进入等待队列时间早的作

业在前。注意考虑到达时间

7、 调度函数：每次从等待队列队首调度优先权最高的作业执行，状态变化。并在执行一个

时间单位后优先权变化，服务时间变化，状态变化。当服务时间为0时，状态变为F。 8、 删除函数：撤销状态为F的作业。

实验要求：

9、 测试数据可以随即输入或从文件中读入。 10、 必须要考虑到作业的到达时间 11、 最终能够计算每一个作业的周转时间。

三、实验代码

#include #include

struct PCB{ charp_name[20]; intp_priority; intp_needTime; intp_runTime; charp_state;

struct PCB* next; };

voidHighPriority(); voidRoundRobin(); void Information(); char Choice();

struct PCB* SortList(PCB* HL);

int main() {

Information();

char choice = Choice(); switch(choice) { case '1':

system(\"cls\"); HighPriority(); break; case '2':

system(\"cls\"); RoundRobin(); break; default: break; }

system(\"pause\"); return 0; }

char Choice() {

printf(\"\\n\\n\");

printf(\" ********************************************* \\n\");

printf(\" 进程调度演示\\n\");

printf(\" ********************************************* \\n\\n\\n\");

printf(\" 1.演示最高优先数优先算法。\\n\"); printf(\" 2.演示轮转法算法。\\n\"); printf(\" 3.退出程序。\\n\\n\\n\\n\");

printf(\" 选择进程调度方法:\"); charch = getchar(); returnch;

system(\"cls\"); }

voidHighPriority() {

struct PCB *processes, *pt;

//pt作为临时节点来创建链表

processes = pt = (struct PCB*)malloc(sizeof(struct PCB)); for (inti = 0; i != 5; ++i) {

struct PCB *p = (struct PCB*)malloc(sizeof(struct PCB)); printf(\"进程号No.%d：\\n\

printf(\"输入进程名：\"); scanf(\"%s\printf(\"输入进程优先数：\"); scanf(\"%d\printf(\"输入进程运行时间：\"); scanf(\"%d\p->p_runTime = 0; p->p_state = 'W'; p->next = NULL; pt->next = p; pt = p;

printf(\"\\n\\n\"); }

getchar(); //接受回车

//processes作为头结点来存储链表 processes = processes->next; int cases = 0;

struct PCB *psorted = processes; while (1) {

++cases; pt = processes;

//对链表按照优先数排序

//psorted用来存放排序后的链表 psorted = SortList(psorted);

printf(\"The execute number: %d\\n\\n\

printf(\"**** 当前正在运行的进程是：%s\\n\psorted->p_state = 'R';

printf(\"qname state super ndtime runtime\\n\");

printf(\"%s\%c\%d\%d\%d\\\n\\n\psorted->p_priority, psorted->p_needTime, psorted->p_runTime); pt->p_state = 'W';

psorted->p_runTime++; psorted->p_priority--;

printf(\"**** 当前就绪状态的队列为：\\n\\n\"); //pt指向已经排序的队列 pt = psorted->next; while (pt != NULL) {

printf(\"qname state super ndtime runtime\\n\");

printf(\"%s\%c\%d\%d\%d\\\n\\n\pt->p_needTime, pt->p_runTime); pt = pt->next; }

//pt指向已经排序的链表，判断链表是否有已用时间啊等于需要时间的 pt = psorted; struct PCB *ap;

ap = NULL; //ap指向pt的前一个节点 while (pt != NULL) {

if (pt->p_needTime == pt->p_runTime) { if (ap == NULL) { pt = psorted->next; psorted = pt;

} else

ap->next = pt->next; } ap = pt;

pt = pt->next; }

if (psorted->next == NULL) break; getchar(); } }

struct PCB* SortList(PCB* HL) {

struct PCB* SL;

SL = (struct PCB*)malloc(sizeof(struct PCB)); SL = NULL;

struct PCB* r = HL; while (r != NULL) {

struct PCB* t = r->next; struct PCB* cp = SL; struct PCB* ap = NULL; while (cp != NULL) {

if (r->p_priority>cp->p_priority) break; else

{ ap = cp;

cp = cp->next;

} }

if (ap == NULL) { r->next = SL;

SL = r; } else

{ r->next = cp; ap->next = r; } r = t; } return SL; }

//轮转算法

voidRoundRobin() {

struct PCB *processes, *pt;

//pt作为临时节点来创建链表

processes = pt = (struct PCB*)malloc(sizeof(struct PCB)); for (inti = 0; i != 5; ++i) {

struct PCB *p = (struct PCB*)malloc(sizeof(struct PCB)); printf(\"进程号No.%d：\\n\printf(\"输入进程名：\"); scanf(\"%s\

printf(\"输入进程运行时间：\"); scanf(\"%d\p->p_runTime = 0; p->p_state = 'W'; p->next = NULL; pt->next = p; pt = p;

printf(\"\\n\\n\"); }

getchar(); //接受回车

//processes作为头结点来存储链表 processes = processes->next; int cases = 0; while (1) {

++cases;

pt = processes;

printf(\"The execute number: %d\\n\\n\

printf(\"**** 当前正在运行的进程是：%s\\n\pt->p_state = 'R';

printf(\"qname state super ndtime runtime\\n\");

printf(\"%s\%c\%d\%d\%d\\\n\\n\pt->p_needTime, pt->p_runTime); pt->p_state = 'W'; pt->p_runTime++; pt->p_priority--;

printf(\"**** 当前就绪状态的队列为：\\n\\n\"); pt = pt->next;

while (pt != NULL) {

printf(\"qname state super ndtime runtime\\n\");

printf(\"%s\%c\%d\%d\%d\\\n\\n\pt->p_needTime, pt->p_runTime); pt = pt->next; }

//检测是否运行时间等于需要时间，是的话从队列里面删除，不是的话加到队列最尾部 pt = processes;

if (pt->p_needTime == pt->p_runTime) {

pt->p_state = 'C'; pt = processes->next; processes = pt; } else

{

if (pt ->next != NULL) {

//寻找最后一个节点 while (pt->next != NULL) pt = pt->next;

struct PCB* ptem;//临时节点用来帮助把头结点插到尾部 ptem = processes->next; pt->next = processes; processes->next = NULL; processes = ptem; } } pt = processes; if (pt == NULL)

break; getchar(); } }

四、实验结果

输入进程名字，进程优先数和进程时间：

图3

图4

图5

图6

图7

图8

PS：仅显示前6个时间片。

五、实验总结

静态优先级 （1）含义

静态优先级是在创建进程时确定进程的优先级，并且规定它在进程的整个运行期间保持不变。

（2）确定优先级的依据

确定优先级的依据通常有下面几个方面：

①进程的类型。通常系统进程优先级高于一般用户进程的优先级；交互型的用户进程的优先级高于批处理作业所对应的进程的优先级。

②进程对资源的需求。例如，进程的估计执行时间及内存需求量少的进程，应赋于较高的优先级，这有利缩小作业的平均周转时间。

③根据用户的要求。用户可以根据自己作业的紧迫程度来指定一个合适的优先级。 （3）优缺点

静态优先级法的优点是 ①简单易行 ②系统开销小。 缺点是

①不太灵活，很可能出现低优先级的作业(进程)，长期得不到调度而等待的情况。

②静态优先级法仅适用于实时要求不太高的系统。 动态优先级 （1）含义

动态优先级是在创建进程时赋予该进程一个初始优先级，然后其优先级随着进程的执行情况的变化而改变，以便获得更好的调度性能。

（2）优缺点

动态优先级优点是使相应的优先级调度算法比较灵活、科学，可防止有些进程一直得不到调度，也可防止有些进程长期垄断处理机。动态优先级缺点是需要花费相当多的执行程序时间，因而花费的系统开销比较大。