一、实验目的

在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理机数时，就必须依照某种策略来决定哪些进程优先占用处理机。本实验模拟在单处理机情况下的进程调度，帮助学生加深了解进程调度的工作。

二、实验内容

设计一个按优先级调度算法实现进程调度的程序。

算法设计思想：

(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、等待时间为0。其它进程等待时间+1，重新计算各进程的响应比，并从大到小排序。

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

0，则再将它加入队尾(因其响应比最小。)；若要求运行时间=0，则把它的状态修改成“结束”(E)，且退出队列。¹(5) 进程运行一次后，若要求运行时间

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

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

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

三、程序设计和说明

程序设计代码如下所示：

#include

#include

#include

#include

#include

#include

using namespace

std;

void

display();//声明函数

int

quantity;

typedef struct

process

{

char pname[20];//进程名

struct process *next;

int BurstTime;//所需时间

int priority; // 数字越大优先级越高

char Status;

}PROCESS;

void

insert(PROCESS *head,PROCESS *p) //入队函数

{

PROCESS *h;

if(head->next ==NULL)

{

head->next =p;

p->next=NULL;

}

else

{

h=head;

while(h->next !=NULL)

{

if((h->next)->priority

>=p->priority )

h=h->next;

else

{

p->next =h->next ;

h->next =p;

break;

}

}

if(h->next ==NULL)

{

h->next =p;

p->next=NULL;

}

}

}

PROCESS

*create() //进程初始化

{

PROCESS *q,*h;

int i,num;

h=(struct process*)malloc(sizeof(struct process));

h->next=NULL;

cout<

cin>>num;

for(i=1;i<=num;i++)

{

q=(struct process*)malloc(sizeof(struct process));

cout<

cin>>q->pname>>q->BurstTime>>q->priority;

q->Status='R';

q->next=NULL;

insert(h,q);

}

cout<

cout<

所需时间 优先数 进程状态\n";

q=h->next;

while(q)

{

q->Status='R';

cout<

"<pname<

"<BurstTime<

"<priority<

"<Status

<

q=q->next;

}

return h;

}

void

run(PROCESS *pt )

{

if(pt->next!=NULL )

{

PROCESS *q;

cout<

cout<

pt->next ->priority --;

pt->next ->BurstTime --;

if(pt->next->BurstTime

==0)

{

pt->next->Status ='E';

cout<next->pname<next->Status

<

q=pt->next;

pt->next=q->next;

free(q);

}

else

{

if(pt->next->next!=NULL)

{

q=pt->next;

pt->next=q->next;

insert(pt,q);

pt->next->Status ='Z';

pt->next->next->Status

='R';

}

else

{

q=pt->next;

pt->next=q->next;

insert(pt,q);

pt->next->Status ='Z';

}

PROCESS *l;

l=pt->next;

cout<

进程名 "<

while(l)

{

cout<<

endl<

"<<

l->pname

<

"<BurstTime

<

"<priority<

"<Status;

l=l->next;

}

}

}

else

{

cout<

cout<

}

cout<

char ch;

if( pt->next)

{

cout<

cin>>ch;

if(ch=='Y'||ch=='y')

{

run(pt);

}

if (ch=='C'||ch=='c')

{

PROCESS *q;

q=(struct process*)malloc(sizeof(struct process));

//先前放在了while前面，不能创建链表进行插入

cout<

<

<

cin>>q->pname>>q->BurstTime>>q->priority;

insert(pt,q);

cout<

cout<

cout<

进程名 "<

q=pt->next;

while(q)

{

q->Status='R';

cout<<

endl<

"<<

q->pname

<

"<BurstTime<

"<priority<

"<Status;

q=q->next;

}

char ch;

if( pt->next)

{

cout<

}

cin>>ch;

if(ch=='Y'||ch=='y')

{

run(pt);

}

}

}

}

void

main()

{

PROCESS *head;

head=create();

if (head!=NULL)

run(head);

cout<

}

四、实验总结

本实验模拟在单处理机情况下的进程调度，使我加深了解进程调度的工作。明白它的工作原理，还有算法的设计思想与运行的优先级别不相同时所打印出来的结果。