进程模拟调度算法课程设计

一．课程概述

1.1.设计构想

程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。

1.2.需求分析

在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目，要使这多个进程能够并发地执行，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统必（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法，短作业优先调度算法，高优先权调度算法，时间片轮转调度算法和多级反馈队列调度算法。

1.3.理论依据

为了描述和管制进程的运行，系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息，系统总是通过PCB对进程进行控制，亦即，系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的，PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。

1.4.课程任务

一、用C语言（或C++）编程实现操作模拟操作系统进程调度子系统的基本功能；运用多

种算法实现对进程的模拟调度。

二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多

级反馈队列调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

三、实现用户界面的开发

1.5.功能模块分析：

1、进程概念：进程是被独立分配资源的最小单位。进程是动态概念，必须程序运行才有

进程的产生。

2、进程的状态模型：

（1）运行：进程已获得处理机，当前处于运行状态。

（2）就绪：进程已经准备好，一旦有处理器就可运行。

3、处理机调度：在多道程序设计系统中，内存中有多道程序运行，他们相互争夺处理机

这一重要的资源。处理机调度就是从就绪队列中，按照一定的算法选择一个进程并将处理机分配给它运行，以实现进程并发地执行。

4、进程调度算法的功能：

记录系统中所有进程的执行情况

选择占有处理机的进程

进行进程的上下文切换

5、进程调度的算法：

（1）先来先服务算法：如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务总是把当前处于就绪队列之首的那个进程调

度到运行状态。

（2）优先数算法：即进程的执行顺序由高优先级到低优先级。系统或用户按某种原则为进程指定一个优先级来表示该进程所享有的确调度优先权。该算法核心是

确定进程的优先级。

（3）时间片轮转算法：固定时间片，每个进程在执行一个时间片后，轮到下一进程执行，知道所有的进程执行完毕。处理器同一个时间只能处理一个任务。处理

器在处理多任务的时候，就要看请求的时间顺序，如果时间一致，就要进行预

测。挑到一个任务后，需要若干步骤才能做完，这些步骤中有些需要处理器参

与，有些不需要（如磁盘控制器的存储过程）。不需要处理器处理的时候，这部

分时间就要分配给其他的进程。原来的进程就要处于等待的时间段上。经过周

密分配时间，宏观上就象是多个任务一起运行一样，但微观上是有先后的，就

是时间片轮换。

(4) 多级反馈队列法：又称反馈循环队列或多队列策略，主要思想是将就绪进程分

为两级或多级，系统相应建立两个或多个就绪进程队列，较高优先级的队列一

般分配给较短的时间片。处理器调度先从高级就绪进程队列中选取可占有处理

器的进程，只有在选不到时，才从较低级的就绪进程队列中选取。

（5）短作业优先法：对短进程优先调度的算法，它是从后备队列中选择一个或者若干个进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事

件而被阻塞放弃处理机时再重新调度。

二．设计方案

2.1．先来先服务调度

2.1.1．算法思想

先来先服务调度算法的思想是按照进程进入就绪队列的先后顺序调度并分配处理机执

行。先来先服务调度算法是一种不可抢占的算法，先进入就绪队列的进程，先被处理机运行。一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某事件而不能继续运行时才释放处理机。

2.1.2．算法流程图

图1.先来先服务算法流程图

2.1.3．程序代码

#include

#include

#include

typedef struct node

{

char name[10]; /*进程名*/

int cputime; /*占用cpu时间*/

char starttime[5]; //进程开始时间

int needtime; /*要求运行时间*/

char state; /*状态*/

struct node *next; /*指针*/

}PCB;

PCB *ready, *run, *finish; //就绪、执行、结束指针

int N; //进程数量

void print() //输出函数

{

PCB *p;

printf(" NAME CPUTIME STARTTIME NEEDTIME STATUS\n");

if(run != NULL)

printf(" %-10s%-10d%-10s%-10d %c\n",

run->name,

run->cputime,

run->starttime,

run->needtime,

run->state); /*输出执行的进程的信息*/

p=ready;

while(p != NULL)

{

printf(" %-10s%-10d%-10s%-10d %c\n",

p->name,

p->cputime,

p->starttime,

p->needtime,

p->state); /*输出就绪进程的信息*/

p=p->next;

}

p=finish;

while(p != NULL)

{

printf(" %-10s%-10d%-10s%-10d %c\n",

p->name,

p->cputime,

p->starttime,

p->needtime,

p->state); /*输出结束队列的信息*/

p=p->next;

}

getchar(); /*使用getchar()函数可以让输出时停留画面，

等待人按回车继续*/

}

void insert(PCB *q) /*插入新进程，把进程按进程到来时间大小排序*/

{

PCB *p1,*s,*r;

int b;

s=q; /*指针s指向新要插入的进程*/

p1=ready; /*指针p1指向原来的进程队列的队首*/

r=p1; /*使用指针r是指向p1前面的进程*/

b=1;

while((p1!=NULL)&&b)

if(strcmp(p1->starttime,s->starttime)<0)

{

r=p1; p1=p1->next;

} /*新进程的开始时间大，则p1 指向下一个进程继续比*/

else

b=0;

if(r!=p1)

{

r->next=s; s->next=p1;

} /*新进程找到位置，插在r和p1之间*/

else

{

s->next=p1; ready=s;

} /*新进程的开始时间按最小，插在队首，并修改就绪队首ready指针*/ }

void create()

{

PCB *p;

int i;

ready=NULL;

run=NULL;

finish=NULL;

printf("Please enter the name and time and starttime of PCB:\n");

/*输入进程名、运行时间和开始时间*/

for(i=0;i

{

p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/

scanf("%s",p->name); /*输入进程名*/

scanf("%d",&p->needtime); /*输入进程要求运行时间*/

scanf("%s",p->starttime); //输入进程开始时间

p->cputime=0;

p->state='W'; /*表示就绪队列中未在队首先执行，但也是就绪状态*/

if (ready!=NULL)

insert(p); /*就绪队首不为NULL，插入新进程*/

else

{ /*否则先插在NULL前*/

p->next=ready;

ready=p;

}

}

printf(" Display is going to start: \n");

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

print();

getchar();

run=ready; /*队列排好，run指向就绪队列队首*/

ready=ready->next; /*ready指向下一个进程*/

run->state='R'; /*队首进程的状态为就绪*/

}

void FCFS()

{

while(run != NULL)

{

run->cputime=run->cputime+run->needtime;

run->needtime=0;

run->next=finish;

finish = run;

run->state='E';

run = NULL;

if(ready != NULL)

{

run = ready;

run->state='R';

ready=ready->next;

}

print();

}

}

void main()

{

printf("Please enter the total number of PCB:\n");

scanf("%d",&N);

create(); /*模拟创建进程，并输入相关信息*/

FCFS(); /*先来先服务调度算法*/

}

2.1.4．测试结果及说明

首先输入进程个数（为5个），这里命名为A,B,C,D,E，然后分别输入运行时间和开始时间所有进程都在队列中，并都处于等待状态

其中一个进程执行完毕

所有进程都执行完毕

2.2．优先级调度

2.2.1．算法思想

进程的执行顺序由高优先级到低优先级，系统或用户按某种原则为进程指定一个优先级来表示该进程所享有的确调度优先权。该算法核心是确定进程的优先级。

2.2.2．算法流程图

图2.优先级调度流程图

2.2.3．程序代码

#include

#include

#include

typedef struct node

{ char name[10]; /*进程名*/

int prio; /*优先数*/

int cputime; /*占用cpu时间

*/

int needtime; /*要求运行时间*/

char state; /*状态*/

struct node *next; /*指针*/

}PCB;

PCB *ready,*run,*finish; /*就绪执行结束指针*/

int N;

void prt() /*输出函数，可以方便看到进程执行的演示*/

{

PCB *p;

printf(" NAME CPUTIME NEEDTIME PRIORITY STATUS\n");

if(run!=NULL)

printf(" %-10s%-10d%-10d%-10d %c\n",run->name,run->cputime,run->need time,run->prio,run->state);

/*输出执行的进程的信息*/

p=ready;

while(p!=NULL)

{printf(" %-10s%-10d%-10d%-10d %c\n",p->name,p->cputime,p->needtime, p->prio,p->state); /*输出就绪进程的信息*/

p=p->next; }

p=finish;

while(p!=NULL)

{ printf(" %-10s%-10d%-10d%-10d %c\n",p->name,p->cputime,p->needtim e,p->prio,p->state); /*输出结束队列的信息*/

p=p->next; }

getchar(); } /*使用getchar()函数可以让输出时停留画面，等待人按回车继续*/

void insert(PCB *q) /*插入新进程，把进程按优先数大小排序*/

{ PCB *p1,*s,*r;

int b;

s=q; /*指针s指向新要插入的进程*/

p1=ready; /*指针p1指向原来的进程队列的队首*/

r=p1; /*使用指针r是指向p1前面的进程*/

b=1;

while((p1!=NULL)&&b)

if(p1->prio>=s->prio) { r=p1; p1=p1->next; } /*新进程的优先数小，则p1 指向下一个进程继续比*/

else b=0;

if(r!=p1) { r->next=s; s->next=p1; } /*新进程找到位置，插在r和p1之间*/

else { s->next=p1; ready=s; } } /*新进程的优先数最大，插在队首，并

修改就绪队首ready指针*/

void create()

{ PCB *p;

int i;

ready=NULL; run=NULL; finish=NULL;

printf("Please enter the name and time and priority of PCB:\n");

/*输入进程名、运行时间和优先级*/

for(i=0;i

{ p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/

scanf("%s",p->name); /*输入进程名*/

scanf("%d",&p->needtime); /*输入进程要求运行时间*/

scanf("%d",&p->prio); /*输入进程优先数*/

p->cputime=0;

p->state='W'; /*表示就绪队列中未在队首先执行，但也是就绪状

态*/

if (ready!=NULL) insert(p); /*就绪队首不为NULL，插入新进程

*/

else { p->next=ready; ready=p; } } /*否则先插在NULL前*/ printf(" Display is going to start: \n");

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

prt();

run=ready; /*队列排好，run指向就绪队列队首*/

ready=ready->next; /*ready指向下一个进程，这样当进程执行时如

果优先数小于其他的进程，应该先进行优先数最大的进程*/

run->state='R'; } /*队首进程的状态为就绪*/

void prio()

{ while(run!=NULL)

{ run->cputime=run->cputime+1; /*运行一次cpu占用时间加一*/

run->needtime=run->needtime-1; /*运行一次要求运行时间减一*/

run->prio=run->prio-1; /*运行一次优先数减一*/

if(run->needtime==0) /*若要求运行时间为0时*/

{ run->next=finish; /*退出队列*/

finish=run; /*finish为结束进程的队列 */

run->state='E'; /*修改状态为结束*/

run=NULL; /*释放run指针*/

if (ready!=NULL) /*创建新就绪队列的头指针*/

{ run=ready; run->state='R'; ready=ready->next; } }

else

if((ready!=NULL)&&(run->prioprio))

/*队首进程的优先数比它下一个小，且下一个进程不为NULL时执行*/

{ run->state='W';

run->next=NULL; /*队首进程退出进程队列*/

insert(run); /*在进程队列中重新插入原来的队首进程*/

run=ready; /*重新置就绪队列的头指针*/

run->state='R';

ready=ready->next; }

prt(); } }

void main()

{ printf("Please enter the total number of PCB:\n");

scanf("%d",&N);

create(); /*模拟创建进程，并输入相关信息*/

prio(); } /*优先数调度算法*/

2.2.4．测试结果及说明

优先级调度算法运行情况如图1，图2，图3，图4所示

图1.输入进程块的数量

图2.输入每个进程的名称、时间、优先级

图3.输入所有的进程的相关信息

图4.所有进程调度算法完成

2.3．时间片轮转调度

2.3.1．算法思想

所有就绪进程按先来先服务的原则排成一个队列，将新来的进程加到就绪对列的末尾，每当执行进程调度时，总是把处理机分配给队首的进程，各进程占用CPU的时间片相同。也就是说CPU的处理时间划分成一个个相同的时间片，就绪队列的所有进程轮流运行一个时间片。当一个时间片结束时，如果运行进程用完它的时间片后还未完成，就强迫运行进程让出CPU，就把它送回到就绪队列的末尾，等待下一次调度。同时，进程调度又去选择就绪队列中的队首进程，分配给它一时间片，以投入运行。直至所有的进程运行完毕。

2.3.2．算法流程图

2.3.3．程序代码

#include

#include

#include

typedef struct node

{

char name[10]; /*进程名*/

int count; /*计数器，判断是否=时间片的大小*/

int cputime; /*占用cpu时间*/

int needtime; /*要求运行时间*/

char state; /*状态*/

struct node *next; /*指针*/

}PCB;

PCB *ready,*run,*finish,*tail; /*就绪执行结束尾指针*/

int N,round;

void prt() /*输出函数，可以方便看到进程执行的演示*/

{

PCB *p;

printf(" NAME CPUTIME NEEDTIME STA TUS\n");

if(run!=NULL)

printf(" %-10s%-10d%-10d %c\n",run->name,run->cputime,run->needti me,run->state); /*输出执行的进程的信息*/

p=ready;

while(p!=NULL)

{

printf(" %-10s%-10d%-10d %c\n",p->name,p->cputime,p->needtime,p-> state); /*输出就绪进程的信息*/

p=p->next;

}

p=finish;

while(p!=NULL)

{

printf(" %-10s%-10d%-10d %c\n",p->name,p->cputime,p->needtime,p-> state); /*输出结束队列的信息*/

p=p->next;

}

getchar();

}

void insert(PCB *q) /*在队尾插入新的进程*/

{

PCB *p;

p=ready;

while(p->next!=NULL)

{

p=ready->next;

}

tail=p;

tail->next=q;

q->next=NULL;

}

void create()

{

PCB *p;

int i;

ready=NULL; run=NULL; finish=NULL;

printf("Please enter the name and time of PCB:\n"); /*输入进程名、和*/

for(i=0;i

{

p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/ scanf("%s",p->name); /*输入进程名*/

scanf("%d",&p->needtime); /*输入进程要求运行时间*/

p->cputime=0;

p->state='W'; /*表示就绪队列中未在队首先执行，但也是就绪状态*/

if (ready!=NULL) insert(p); /*就绪队首不为NULL，插入新进程*/

else

{

p->next=ready; ready=p; tail=p;

}

}

printf(" Display is going to start: \n");

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

prt();

getchar();

run=ready; /*队列排好，run指向就绪队列队首*/

ready=ready->next; /*ready指向下一个进程*/

run->state='R';

} /*队首进程的状态为就绪*/

void count()

{

while(run!=NULL)

{

run->cputime=run->cputime+1; /*运行一次cpu占用时间加一*/

run->needtime=run->needtime-1; /*运行一次要求运行时间减一*/

run->count=run->count+1; /*运行一次计数器加一*/

if(run->needtime==0) /*若要求运行时间为0时*/

{

run->next=finish; /*退出队列*/

finish=run; /*finish为结束进程的队列*/

run->state='E'; /*修改状态为结束*/

run=NULL; /*释放run指针*/

if (ready!=NULL) /*创建新就绪队列的头指针*/

{

run=ready; run->state='R'; ready=ready->next;

}

}

else

if(run->count==round) /*如果时间片到*/

{

run->count=0; /*计数器置0*/

if(ready!=NULL) /*如就绪队列不空*/

{

run->state='W';

insert(run); /*在进程队列中重新插入原来进程,插入队尾*/

run=ready; /*重新置就绪队列的头指针*/

run->state='R';

ready=ready->next;

}

}

prt();

}

}

void main()

{

printf("Please enter the total number of PCB:\n");

scanf("%d",&N);

create(); /*模拟创建进程，并输入相关信息*/

count(); /*优先数调度算法*/

}

2.3.4．测试结果及说明

时间片轮转调度算法运行情况如图1，图2，图3所示

图1 所有的进程都在队列中

图2 其中一个进程执行完毕

图4 所有的进程都执行完毕

2.4．多级反馈队列调度

2.4.1算法思想

允许进程在队列之间移动。在系统中设置多个就绪队列，每个队列对应一个优先级，第一个队列的优先级最高，第二队列次之。以下各队列的优先级逐步低。各就绪队列中的进程的运行时间片不同，高优先级队列的时间片小，低优先级队列的时间片大。进程并非总是固定在某一队列中，新进程进入系统后，被存放在第一个队列的末尾。如果某个进程在规定的

时间片内没有完成工作，则把它转入到下一个队列的末尾，直至进入最后一个队列。系统先运行第一个队列中的进程。当第一队列为空时，才运行第二个队列中的进程。依此类推，仅当前面所有的队列都为空时，才运行最后一个队列中的进程。当处理器正在第i个队列中为某个进程服务时，又有新进程进入优先级最高的队列（第1—（i-1）中的任何一个对列），则此新进程要抢占正在运行进程的处理器，即由调度程序把正在运行的进程放回第i队列的末尾，把处理器分配给新到的高优先级进程。除最低优先权队列外的所有其他队列，均采用相同的进程调度算法，即按时间片轮转的FIFO（先进先出）算法。最后一个队列中的进程按按时间片轮转或FCFS策略进行调度。它是综合了FIFO、RR和剥夺式HPF的一种进程调度算法。

2.4.2算法流程图

2.4.3程序代码

#include

#include

#include

#define NULL 0

typedef struct node

{

char name[10]; /*进程名*/

int num; /*进程所在队列数,也是该队列的时间片*/

int cputime; /*占用cpu时间*/

int needtime; /*要求运行时间*/

struct node *next; /*指针*/

}PCB;

PCB *qf1,*ql1;

PCB *qf2,*ql2;

PCB *qf3,*ql3;//定义三个队列的头指针和尾指针

int blog1,blog2,blog3; /*分别记录队列1,、队列2、队列3中进程数*/

void insert(PCB *q,PCB *qf,PCB *ql)

{

q->num++;

if(qf==NULL&&ql==NULL)

{ //队列为空

qf=ql=q;

}

else

{//队列不为空

ql->next=q;

ql=q;

}

ql->next=NULL;

}

void create(int n)

{//创建进程，刚来的进程都进入队列1

PCB *p;

p=(PCB *)malloc(sizeof(PCB));

int i;

blog1=blog2=blog3=0; //各队列中进程数均为0

printf("Please enter the name and needtime of PCB:\n");

/*输入进程名和所需时间*/

for(i=0;i

{

//p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/

scanf("%s",p->name); /*输入进程名*/

scanf("%d",&(p->needtime)); /*输入进程要求运行时间*/

p->cputime=0;

p->num=0;

insert(p,qf1,ql1);

blog1++; //队列中进程数加1

}

}

int run(PCB *q,PCB *qf,PCB *ql)

{

PCB *p,*f,*l;

/*p=(PCB *)malloc(sizeof(PCB));

f=(PCB *)malloc(sizeof(PCB));

l=(PCB *)malloc(sizeof(PCB));*/

p=q;

f=qf;

l=ql;

if(q->needtime<=q->num) /*在时间片内完成*/

{

//q->cputime+=q->needtime;

q->needtime=0;

free(q);

return 0;

}

else /*不能在时间片内完成*/

{

//q->cputime+=q->num;

q->needtime-=q->num;

if(q->num<3)

q->num++;

insert(p,f,l); //进入下一个队列

return 1;

}

}

void prt() /*输出函数，可以方便看到进程执行的演示*/

{

PCB *p;

//p=(PCB *)malloc(sizeof(PCB));

int a;

printf(" NAME CPUTIME NEEDTIME STA TUS\n");

while(blog1>0||blog2>0||blog3>0)

{

if(blog1>0) /*第一个队列不为空*/

{

p=qf1;

qf1=qf1->next;

p->next=NULL;

blog1--;

printf(" %-10s%-10d%\n",p->name,p->needtime);

a=run(p,qf2,ql2);

if(a==1)

blog2++;

}

else if(blog2>0) /*第二个队列不为空*/

{

p=qf2;

qf2=qf2->next;p->next=NULL;

blog2--;

printf(" %-10s%-10d%\n",p->name,p->needtime);

a=run(p,qf3,ql3);

if(a==1)

blog3++;

}

else if(blog3>0) /*第三个队列不为空*/

{

p=qf3;

qf3=qf3->next;p->next=NULL;

blog3--;

printf(" %-10s%-10d%\n",p->name,p->needtime);

a=run(p,qf3,ql3);

if(a==1)

blog3++;

}

}

} /*使用getchar()函数可以让输出时停留画面，等待人按回车继续*/ void main()

{

qf1=ql1=(PCB *)malloc(sizeof(PCB));

qf2=ql2=(PCB *)malloc(sizeof(PCB));

qf2=ql2=(PCB *)malloc(sizeof(PCB));

int n;

blog1=blog2=blog3=0;

printf("请输入进程的个数: ");

scanf("%d",&n);

create(n);

prt();

}

2.4.4测试结果及说明

2.5．短作业调度

2.5.1．算法思想

短作业优先调度算法是指对短作业进行调度的算法。它从后备队列总选择一个或若干个运行时间最短的作业，将他们调入内存运行。

2.5.2．算法流程图：

2.5.3．程序代码

#include

#include

#include

typedef struct node

{

char name[10]; /*进程名*/

int cputime; /*占用cpu时间*/

int needtime; /*要求运行时间*/

char state; /*状态*/

struct node *next; /*指针*/

}PCB;

PCB *ready, *run, *finish; //就绪、执行、结束指针

int N; //进程数量

void print() //输出函数

{

PCB *p;

printf(" NAME CPUTIME NEEDTIME STATUS\n");

if(run != NULL)

printf(" %-10s%-10d%-10d %c\n",

run->name,

run->cputime,

run->needtime,

run->state); /*输出执行的进程的信息*/

p=ready;

while(p != NULL)

{

printf(" %-10s%-10d%-10d %c\n",

p->name,

p->cputime,

p->needtime,

p->state); /*输出就绪进程的信息*/

p=p->next;

}

p=finish;

while(p != NULL)

{

printf(" %-10s%-10d%-10d %c\n",

p->name,

p->cputime,

p->needtime,

p->state); /*输出结束队列的信息*/

p=p->next;

}

getchar(); /*使用getchar()函数可以让输出时停留画面，

等待人按回车继续*/

}

void insert(PCB *q) /*插入新进程，把进程按进程到来时间大小排序*/ {

PCB *p1,*s,*r;

int b;

s=q; /*指针s指向新要插入的进程*/

p1=ready; /*指针p1指向原来的进程队列的队首*/

r=p1; /*使用指针r是指向p1前面的进程*/

b=1;

while((p1!=NULL)&&b)

if(p1->needtimeneedtime)

{

r=p1; p1=p1->next;

} /*新进程的开始时间大，则p1 指向下一个进程继续比*/

else

b=0;

if(r!=p1)

{

r->next=s; s->next=p1;

} /*新进程找到位置，插在r和p1之间*/

else

{

s->next=p1; ready=s;

} /*新进程的开始时间按最小，插在队首，并修改就绪队首ready指针*/ }

void create()

{

PCB *p;

int i;

ready=NULL;

run=NULL;

finish=NULL;

printf("Please enter the name and time of PCB:\n");

/*输入进程名、运行时间和开始时间*/

for(i=0;i

{

p=(PCB *)malloc(sizeof(PCB)); /*为新进程开辟空间*/

scanf("%s",p->name); /*输入进程名*/

scanf("%d",&p->needtime); /*输入进程要求运行时间*/

p->cputime=0;

p->state='W'; /*表示就绪队列中未在队首先执行，但也是就绪状态*/

if (ready!=NULL)

insert(p); /*就绪队首不为NULL，插入新进程*/

else

{ /*否则先插在NULL前*/

p->next=ready;

ready=p;

}

}

printf(" Display is going to start: \n");

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

print();

getchar();

run=ready; /*队列排好，run指向就绪队列队首*/

ready=ready->next; /*ready指向下一个进程*/

run->state='R'; /*队首进程的状态为就绪*/

}

void SJF()

{

while(run != NULL)

{

run->cputime=run->cputime+run->needtime;

run->needtime=0;

run->next=finish;

finish = run;

run->state='E';

run = NULL;

if(ready != NULL)

{

run = ready;

run->state='R';

ready=ready->next;

}

print();

}

}

void main()

{

printf("Please enter the total number of PCB:\n");

scanf("%d",&N);

create(); /*模拟创建进程，并输入相关信息*/

SJF(); /*短作业优先调度算法*/

}

2.5.4．测试结果截图及操作说明

首先输入2个控制进程快，分别命名s1和s2 ，并且时间分别是2和5.短作业优先调度算法运行情况如4-7到4-9所示

。

图4-7所有作业都在队列中，并都处于等待状态

图4-8其中一个作业执行完毕

图4-9所有进程执行完毕

三．测试分析

1.先来先服务算法比较有利于长作业（进程），而不利于短作业（进程）。因为短作业运行时间很短，如果让它等待较长时间才得到服务，那么，它的带权周转时间就会很高；先来先服务调度算法有利于CPU繁忙型的作业，不利于I/O繁忙型的作业，而目前大多数事务处理都属于I/O繁忙型作业。

2.短作业优先调度算法能有效地降低作业的平均等待时间，提高系统吞吐量。然而该算法对长作业不利，因为调度程序总是优先调度那些短作业，将导致长作业长期不被调度，该算法完全未考虑作业的紧迫程度，因而不能保证紧迫性作业会被及时处理，由于作业的长短只是根据用户提供的估计执行时间而定的，而用户又可能有意无意地缩短其作业的估计运行时间，致使该算法不能真正做到短作业优先调度；

3.优先级调度算法则保证了紧迫进程，而那些优先级较低的则可能长时间得不到调度；静态优先级调度算法简单易行，系统开销小，但是不太灵活，很可能出现低优先级的作业，长期得不到调度而等待的情况；静态优先级法仅适合于实现要求不太高的系统。动态优先级调度算法比较灵活科学，可防止有一些进程一直得不到调度，也可防止有些进程长期垄断处理机，但是需要花费相当多的执行程序时间，因而花费的系统开销比较大。

4.时间片轮转算法则算是对每个进程都是公平的，减少了进程的等待时间，但是时间片设得太短会导致过多的进程切换，降低了CPU效率；而设得太长又可能引起对短的交互请求的响应变差。将时间片设为100毫秒通常是一个比较合理的折衷；

进程调度算法模拟 (操作系统课程设计报告)

福建农林大学计算机与信息学院 课程设计报告 课程名称：操作系统 实习题目：进程调度算法模拟 姓名： 系：计算机科学与技术系 专业：计算机科学与技术 年级：2012 学号： 指导教师： 职称：副教授 年月日

福建农林大学计算机与信息学院计算机类 课程设计结果评定

目录 1.本选题课程设计的目的 (4) 2.本选题课程设计的要求 (4) 3.本选题课程设计报告内容 (4) 3．1前言 (4) 3．2进程调度算法模拟的环境 (4) 3．3系统技术分析 (4) 3．4系统流程图及各模块 (5) 3．5程序调试情况 (8) 4．总结 (11) 参考文献 (11) 程序代码 (12)

1.设计目的 课程设计将课本上的理论知识和实际有机的结合起来，锻炼学生的分析系统，解决实际问题的能力。提高学生分析系统、实践编程的能力。 2.设计要求 利用学到的操作系统和编程知识，完成具有一定难度的系统分析研究或系统设计题目。其中：专题系统理论研究应包括研究目的、目标，论点和论据以及证明推导等；分析、设计系统应包括编写、调试程序以及最后写出设计报告或系统说明文档文件，系统说明文档包括系统界面、变量说明、系统功能说明、编程算法或思路、流程图和完整程序。具体要求如下： 1、对系统进行功能模块分析、控制模块分析正确； 2、系统设计要实用； 3、编程简练，可用，功能全面； 4、说明书、流程图要清楚。 3.设计方案 3.1前言 本程序包括三种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 3.2本选题设计的环境 WindowsXP下的Microsoft Visual C++ 6.0 3.3系统技术分析 （1）编程实现对N个进程采用某种进程调度算法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度算法）调度执行的模拟。（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：进程标识数ID。 进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。

时间片轮转进程调度模拟算法的实现

武汉理工大学华夏学院课程设计报告书 课程名称：操作系统原理 题目：时间片轮转进程调度模拟算法的实现系名：信息工程系 专业班级：计算机1132班 姓名：李杰 学号： 10210413209 指导教师: 司晓梅 2015年 6 月 26日

武汉理工大学华夏学院信息工程系 课程设计任务书 课程名称：操作系统原理课程设计指导教师：司晓梅 班级名称：计算机1131-2 开课系、教研室：自动化与计算机 一、课程设计目的与任务 操作系统课程设计是《操作系统原理》课程的后续实践课程，旨在通过一周的实践训练， 加深学生对理论课程中操作系统概念，原理和方法的理解，加强学生综合运用操作系统原理、 Linux系统、C语言程序设计技术进行实际问题处理的能力，进一步提高学生进行分析问题 和解决问题的能力，包含系统分析、系统设计、系统实现和系统测试的能力。 学生将在指导老师的指导下，完成从需求分析，系统设计，编码到测试的全过程。 二、课程设计的内容与基本要求 1、课程设计题目 时间片轮转进程调度模拟算法的实现 2、课程设计内容 用c/c++语言实现时间片轮转的进程调度模拟算法。要求： 1．至少要有5个以上进程 2．进程被调度占有CPU后，打印出该进程正在运行的相关信息 提示: 时间片轮转调度算法中，进程调度程序总是选择就绪队列中的第一个进程，也就是说按照先来先服务原则调度，但一旦进程占用处理机则仅使用一个时间片。在使用完一个时间片后，进程还没有完成其运行，它必须释放出处理机给下一个就绪的进程，而被抢占的进程返回到就绪队列的末尾重新排队等待再次运行。 1）进程运行时，只打印出相关提示信息，同时将它已经运行的时间片加1就可以了。 2）为进程设计出PCB结构。PCB结构所包含的内容，有进程名、进程所需运行时间、已运行时间和进程的状态以及指针的信息等。 3、设计报告撰写格式要求： 1设计题目与要求 2 设计思想 3系统结构 4 数据结构的说明和模块的算法流程图 5 使用说明书（即用户手册）：内容包含如何登录、退出、读、写等操作说明 6 运行结果和结果分析（其中包括实验的检查结果、程序的运行情况）

实验一 模拟实现进程调度算法

实验一模拟实现进程调度算法(4学时) ①、实验目的 a、进程调度是处理机管理的核心内容。观察、体会操作系统的进程调度方法，并通过一个简单的进程调度模拟程序的实现，加深对进程控制块、进程队列、进程调度算法，进程切换的理解，并体会和了解各种调度算法的具体实施办法。 b、提高实际动手编程能力，为日后从事软件开发工作打下坚实基础。 ②、实验内容 a、设计进程控制块PCB表结构，模拟实现进程调度算法：FIFO，静态优先级调度，时间片轮转调度，短进程优先调度算法，多级反馈队列调度。（实现静态优先级调度算法、短进程优先调度算法）。 b、编写一个进程调度程序模拟程序。模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 c、由用户输入（可通过文件输入）进程名、进程状态、进程运行时间和进程优先级等数据。 ③、实验要求 a、使用模块化设计思想来设计。 b、给出主函数和各个算法函数的流程图。 c、学生可按照自身条件，随意选择采用的算法，（例如：采用冒泡法编写程序，实现短进程优先调度的算法）。 d、进程调度程序模拟程序只对PCB进行相应的调度模拟操作，不需要实际程序。 ④、运行结果 a、给出进程的调度模拟操作排序结果。 ⑤、提示 a、每个进程可有三个状态，并假设初始状态为就绪状态。 b、为了便于处理，程序中的进程运行时间以纳秒为单位计算。 C、各进程的优先级或轮转时间数以及进程需运行的纳秒数的初始值均由用户给定。 d、在优先级算法中，采用静态优先级。在时间片轮转算法中，采用可变时间片，由用户给定。 e、对于遇到优先级一致的情况，采用FIFO策略解决。

f、输入：进程流文件（文本文件），其中存储的是一系列要执行的进程，每个进程包括四个数据项：进程名进程状态(1就绪2等待3运行) 所需时间优先级(0级最高)。 g、输出：进程执行流等待时间平均等待时间。 ⑥、分析与讨论 a、各种进程调度算法的异同？ b、如何理解“算法+数据结构=程序设计”？ c、如何理解“数据结构始终是为实现功能服务的”？ ⑦、参考代码 参看：附录A1 考核方法： 1、实验报告占50%，程序设计30%，出勤占20%； 3、每次实验100分，2次实验的平均分为最终实验成绩。 注：无出勤只交实验报告者，以实验报告成绩×50%为最后成绩。 打游戏者发现一次本次实验扣10分。 早退者本次实验扣10分。 点名时未到者，后来补签到按照迟到时间长短扣分，点名后即来扣5分，1节课过后才来扣10分。

2011180021-Linux操作系统-课程设计报告-基于Linux的进程调度模拟程序

河南中医学院 《linux操作系统》课程设计报告 题目：基于Linux的进程调度模拟程序 所在院系：信息技术学院 专业年级：2011级计算机科学与技术完成学生：2011180021 郭姗 指导教师：阮晓龙 完成日期：201X 年06 月22 日 目录 1. 课程设计题目概述3 2. 研究内容与目的4 3. 研究方法5 4. 研究报告6 5. 测试报告/实验报告7 6. 课题研究结论8 7. 总结9

1、课程设计题目概述 随着Linux系统的逐渐推广，它被越来越多的计算机用户所了解和应用. Linux是一个多任务的操作系统，也就是说，在同一个时间内，可以有多个进程同时执行。如果读者对计算机硬件体系有一定了解的话，会知道我们大家常用的单CPU计算机实际上在一个时间片断内只能执行一条指令，那么Linux是如何实现多进程同时执行的呢？原来Linux使用了一种称为"进程调度（process scheduling）"的手段，首先，为每个进程指派一定的运行时间，这个时间通常很短，短到以毫秒为单位，然后依照某种规则，从众多进程中挑选一个投入运行，其他的进程暂时等待，当正在运行的那个进程时间耗尽，或执行完毕退出，或因某种原因暂停，Linux就会重新进行调度，挑选下一个进程投入运行。因为每个进程占用的时间片都很短，在我们使用者的角度来看，就好像多个进程同时运行一样了。本文就是对进程调度进行研究、实验的。 本文首先对Linux系统进行了简要的介绍, 然后介绍了进程管理的相关理论知识。其次，又介绍最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）、先来先服务算法的相关知识，并对进程调度进行最高优先数优先的调度算法和先来先服务算法模拟实验，并对比分析两种算法的优缺点，从而加深对进程概念和进程调度过程/算法的理解 设计目的：在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个。也就是说能运行的进程数大于处理机个数。为了使系统中的进程能有条不紊地工作，必须选用某种调度策略，选择某一进程占用处理机。使得系统中的进程能够有条不紊的运行，同时提高处理机的利用率以及系统的性能。所以设计模拟进程调度算法（最高优先数优先的调度算法、先来先服务算法），以巩固和加深处理进程的概念，并且分析这两种算法的优缺点。关键词：linux 进程调度调度算法

进程调度算法模拟实验

华北科技学院计算机系综合性实验 实验报告 课程名称操作系统C 实验学期2012至2013学年第2学期学生所在系部计算机系 年级专业班级 学生姓名学号 任课教师杜杏菁 实验成绩 计算机系制

《操作系统C》课程综合性实验报告 开课实验室：基础六机房2013年6月3日 实验题目进程调度算法模拟 一、实验目的 通过对进程调度算法的模拟，进一步理解进程的基本概念，加深对进程运行状态和进程调度过程、调度算法的理解。 二、设备与环境 1.硬件设备：PC机一台 2.软件环境：安装Windows操作系统或者Linux操作系统，并安装相关的程序开发环境，如C \C++\Java等编程语言环境。 三、实验内容 （1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段： ?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进 入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将 转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。

进程调度算法的模拟实现

操作系统课程设计报告题目：进程调度算法的模拟实现_ 专业计算机科学与技术 学生姓名 班级 学号 指导教师 发放日期2015.1.30 信息工程学院

目录 1 概述 (1) 2 设计原理 (1) 2.1先来先服务算法 (1) 3 详细设计与编码 (2) 3.1 模块设计 (2) 3.2 系统流程图 (2) 3.3 系统详细设计 (2) 4 结果与分析 (6) 4.1 测试方案 (6) 4.2 测试结果 (6) 4.3 测试结果分析 (9) 5 设计小结 (10) 6 参考文献 (10) 附录程序代码 (12)

进程调度算法的模拟实现 进程调度算法的模拟实现 1 概述 选择一个调度算法，实现处理机调度，进程调度算法包括：先来先服务算法，短进程优先算法，时间片轮转算法，动态优先级算法。可选择进程数量，本程序包括四种算法，用C或C++语言实现，执行时在主界面选择算法（可用函数实现），进入子页面后输入进程数，（运行时间，优先数由随机函数产生），执行，显示结果。 2 设计原理 2.1先来先服务(FCFS)算法 每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列 2.2 时间片轮转法(RR)算法 系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。时间片的大小从几ms到几百ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。 2.3短作业优先(SJF)算法 短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。 2.4最高优先权优先(HRRN)算法 优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。动态优先权是指在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。

操作系统课程设计报告进程调度

前言操作系统（OperatingSystem，简称OS）是管理和控制计算机硬件与软件资源的计算机程序，是直接运行在“裸机”上的最基本的系统软件，任何其他软件都必须在操作系统的支持下才能运行。 操作系统是用户和计算机的接口，同时也是计算机硬件和其他软件的接口。操作系统的功能包括管理计算机系统的硬件、软件及数据资源，控制程序运行，改善人机界面，为其它应用软件提供支持，让计算机系统所有资源最大限度地发挥作用，提供各种形式的用户界面，使用户有一个好的工作环境，为其它软件的开发提供必要的服务和相应的接口等。实际上，用户是不用接触操作系统的，操作系统管理着计算机硬件资源，同时按照应用程序的资源请求，分配资源，如：划分CPU时间，内存空间的开辟，调用打印机等。 操作系统的主要功能是资源管理，程序控制和人机交互等。计算机系统的资源可分为设备资源和信息资源两大类。设备资源指的是组成计算机的硬件设备，如中央处理器，主存储器，磁盘存储器，打印机，磁带存储器，显示器，键盘输入设备和鼠标等。信息资源指的是存放于计算机内的各种数据，如系统软件和应用软件等。 操作系统位于底层硬件与用户之间，是两者沟通的桥梁。用户可以通过操作系统的用户界面，输入命令。操作系统则对命令进行解释，驱动硬件设备，实现用户要求。

本次课程设计我们将对上学期所学的知识进行系统的应用，而达到巩固知识的作用

目录 1问题概述.................................................................................................... 2需求分析.................................................................................................... 3概要设计.................................................................................................... 3.1主要功能................................................................................................. 3.2模块功能结构 ........................................................................................ 3.3软硬件环境............................................................................................. 3.4数据结构设计 ........................................................................................ 4详细设计.................................................................................................... 4.1“先来先服务（FCFS）调度算法” ....................................................... 4.2“短进程调度算法（SPF）”.................................................................. 4.3“高响应比优先调度算法”................................................................. 4.4“优先级调度（非抢占式）算法”.......................................................... 5系统测试及调试 ....................................................................................... 5.1测试......................................................................................................... 5.2调试过程中遇到的问题 ........................................................................ 6心得体会.................................................................................................... 7参考文献.................................................................................................... 8附录............................................................................................................

进程调度算法实验报告

实验报告 实验一：进程调度算法 一、实验目的 1．利用高级语言实现三种不同及进程调度算法： 短作业优先算法、时间片轮转调度算法和优先级调度算法。 2．通过实验理解有关进程控制块，进程队列等的概念。 二、实验原理 各调度算法思想： 1.先来先服务算法(FCFS)： 按照进程进入就绪队列的先后次序来分配CPU，一旦一个进程占有CPU，就一直运行下去，知道该进程完成工作，才释放CPU。 2.时间片轮转算法: 系统将所有就绪进程按到达时间的先后次序排成一个队列，进程调度程序总是选择队列中的第一个进程执行，且仅能执行一个时间片，在使用完一个时间片后，即使进程并未完成其运行，也必须将CPU交给下一个进程；如果一个时间片未使用完就完成了该进程，则剩下的时间分配给下一个进程。 3.优先权调度算法；在创建进程时就确定优先权，确定之后在整个程序运行期间不再改 变，根据优先级排列，系统会把CPU分配给优先权最高的进程。 三、实验步骤、数据记录及处理 1、算法流程

抽象数据类型的定义：PCB块结构体类型 struct PCB { int name; int arrivetime; // 到达时间 int servicetime; // 服务时间 //int starttime[max]; // 开始时间 int finishtime; // 完成/ 结束时间 int turntime; // 周转时间 int average_turntime; // 带权周转时间 int sign; // 标志进程是否完成 int remain_time; // 剩余时间 int priority; // 优先级 }pcb[max]; 主程序的流程以及各程序模块之间的层次( 调用) 关系：主程序中从键盘得到进程的数量，创建PCB，调用layout ()函数显示选择界面。 Layout ()函数中选择相应的算法并调用相关函数如：FCFS()、time_segment(); Priority() ，这三个函数分别实现先来先服务算法，时间片轮转算法和优先级算法，最后分别打印。 程序流程图：

进程模拟调度算法课程设计

一．课程概述 1.1.设计构想 程序能够完成以下操作：创建进程：先输入进程的数目，再一次输入每个进程的进程名、运行总时间和优先级，先到达的先输入；进程调度：进程创建完成后就选择进程调度算法，并单步执行，每次执行的结果都从屏幕上输出来。 1.2.需求分析 在多道程序环境下，主存中有着多个进程，其数目往往多于处理机数目，要使这多个进程能够并发地执行，这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使之执行。分配处理机的任务是由处理机调度程序完成的。由于处理机是最重要的计算机资源，提高处理机的利用率及改善系统必（吞吐量、响应时间），在很大程度上取决于处理机调度性能的好坏，因而，处理机调度便成为操作系统设计的中心问题之一。本次实验在VC++6.0环境下实现先来先服务调度算法，短作业优先调度算法，高优先权调度算法，时间片轮转调度算法和多级反馈队列调度算法。 1.3.理论依据 为了描述和管制进程的运行，系统为每个进程定义了一个数据结构——进程控制块PCB(Process Control Block),PCB中记录了操作系统所需的、用于描述进程的当前情况以及控制进程运行的全部信息，系统总是通过PCB对进程进行控制，亦即，系统是根据进程的PCB 而不是任何别的什么而感知进程的存在的，PCB是进程存在的惟一标志。本次课程设计用结构体Process代替PCB的功能。 1.4.课程任务 一、用C语言（或C++）编程实现操作模拟操作系统进程调度子系统的基本功能；运用多 种算法实现对进程的模拟调度。 二、通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转、短作业优先、多 级反馈队列调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。 三、实现用户界面的开发

操作系统-课程设计

课程设计说明书（操作系统） 题目：进程调度 院系：计算机科学与工程学院 专业班级：信息安全13-2 学号：20133029xx 学生姓名：xx 指导教师：xx 2015年12月15日

安徽理工大学课程设计（论文）任务书计算机科学与工程学院

安徽理工大学课程设计（论文）成绩评定表

摘要 现代计算机系统中，进程是资源分配和独立运行的基本单位，是操作系统的核心概念。因而，进程就成为理解操作系统如何实现系统管理的最基本，也是最重要的概念。进程调度是进程管理过程的主要组成部分，是必然要发生的事件。 在现代操作系统中，进程的并发机制在绝大多数时候，会产生不断变化的进程就绪队列和阻塞队列。处于执行态的进程无论是正常或非正常终止、或转换为阻塞状态，都会引发从就绪队列中，由进程调度选择一个进程进占CPU。 进程调度的核心是进程调度的算法．在本课程设计中，用良好清晰的界面向用户展示了进程调度中的时间片轮转调度算法。在最终实现的成果中，用户可指定需要模拟的进程数，CPU时间片和进程的最大执行时间，并且选择需要演示的算法，界面将会动态的显示进程调度过程及各个队列的变化。通过此进程调度模拟系统，用户可以对时间片轮转调度算法有进一步以及直观的了解。 关键词:进程，调度，PCB，时间片轮转

目录 1.设计目的 (6) 2.设计思路 (6) 3.设计过程 (8) 3.1流程图 (8) 3.2算法 (8) 3.3数据结构 (10) 3.4源代码 (10) 4.实验结果及分析 (20) 4.1 使用说明 (20) 4.2程序演示 (20) 5.实验总结 (24) 6.参考文献 (24)

进程调度算法模拟程序设计C++

（1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。 （2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：?进程标识数ID。 ?进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。 ?进程已占用CPU时间CPUTIME。 ?进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。 ?进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间 片后，进程将进入阻塞状态。 ?进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME 个时间片后，将转换成就绪状态。 ?进程状态STATE。 ?队列指针NEXT，用来将PCB排成队列。 （3）优先数改变的原则： ?进程在就绪队列中呆一个时间片，优先数增加1。 ?进程每运行一个时间片，优先数减3。 （4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。 （5）分析程序运行的结果，谈一下自己的认识。 实验代码 #include "iostream.h" #include "windows.h" //#define N 3 typedef struct{ int ID; int PRIORITY; int CPUTIME;

int ALLTIME; int STARTBLOCK; int BLOCKTIME; int STATE;//0-运行1-阻塞2-就绪3-结束4-未到达 int REACH; int TIME; }PROCESS; void textcolor (int color) { SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE), color ); } void main(){ int i,time,max,l,l1,time1,flag=0,total=0,N,server[10],sum=0; PROCESS pro[10]; textcolor(13); cout<<"注意：本程序中状态代表如下"<>N; cout<<"请设置时间片长度:"; cin>>time; cout<<"请输入各进程初始状态:"<>pro[i].ID>>pro[i].PRIORITY>>pro[i].REACH;

《高级语言程序设计》课程设计报告

2013-2014学年第二学期《高级语言程序设计》 课程设计报告 题目：进程调度模拟 专业：计算机科学与技术 班级：12级对口（3）班 姓名：刘以鹏 指导教师：代美丽 成绩： 计算机与信息工程系 2014年 5月 23日

目录 1 1 设计目的及要求 (3) 1.1 设计目的 (3) 1.2 课程设计的实验环境 (3) 1.3 课程设计的预备知识 (3) 1.4 课程设计要求 (3) 2 课程设计内容 (3) 2.1程序功能介绍 (3) 2.2程序整体设计说明 (4) 2.2.1设计思路 (4) 2.2.2数据结构设计及用法说明 (5) 2.2.3程序结构（流程图） (5) 2.2.4各模块的功能及程序说明 (6) 2.2.5程序运行结果 (7) 3 总结 (9) 参考资料 (11) 程序源代码 (12)

1 设计目的及要求 1.1 设计目的 本课程设计是计算机科学与技术专业重要的实践性环节之一，是在学生学习完《程序设计语言(C)》课程后进行的一次全面的综合练习。本课程设计的目的和任务： 1. 巩固和加深学生对C语言课程的基本知识的理解和掌握 2. 掌握C语言编程和程序调试的基本技能 3. 利用C语言进行基本的软件设计 4. 掌握书写程序设计说明文档的能力 5. 提高运用C语言解决实际问题的能力 1.2 课程设计的实验环境 硬件要求能运行Windows 2000/XP操作系统的微机系统。C语言程序设计及相应的开发环境。 1.3 课程设计的预备知识 熟悉C语言及C语言开发工具。 1.4 课程设计要求 1. 分析课程设计题目的要求 2. 写出详细设计说明 3. 编写程序代码，调试程序使其能正确运行 4. 设计完成的软件要便于操作和使用 5. 设计完成后提交课程设计报告 2课程设计内容 2.1程序功能介绍 在多道程序环境下，进程数目往往多于处理机数目，致使他们争用处理机。这就要求系统能按某种算法，动态地把处理机分配给就绪队列中的一个进程，使

模拟磁盘调度算法操作系统课程设计

模拟磁盘调度算法操作系 统课程设计 The following text is amended on 12 November 2020.

某某大学 课程设计报告课程名称：操作系统 设计题目：模拟磁盘调度算法 系别：计算机系 专业：计算机科学与技术 组别： 学生姓名: 学号: 起止日期: 指导教师:

目录

第一章需求分析 课程设计的简介 这是一个用VC++为工具、C++为编程语言而实现模拟先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）的一个磁盘调度程序。该程序设计系统主界面可以灵活选择某种算法并算出磁头移动的总磁道数以及平均磁道数。 课程设计的目的 本课程设计的目的是通过设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）等磁盘调度算法的理解。 磁盘调度主要思想 设备的动态分配算法与进程调度相似，也是基于一定的分配策略的。常用的分配策略有先请求先分配、优先级高者先分配等策略。在多道程序系统中，低效率通常是由于磁盘类旋转设备使用不当造成的。操作系统中，对磁盘的访问要求来自多方面，常常需要排队。这时，对众多的访问要求按一定的次序响应，会直接影响磁盘的工作效率，进而影响系统的性能。访问磁盘的时间因子由3部分构成，它们是查找（查找磁道）时间、等待（旋转等待扇区）时间和数据传输时间，其中查找时间是决定因素。因此，磁盘调度算法先考虑优化查找策略，需要时再优化旋转等待策略。 平均寻道长度（L）为所有磁道所需移动距离之和除以总的所需访问的磁道数（N），即： L=（M1+M2+……+Mi+……+MN）/N。其中Mi为所需访问的磁道号所需移动的磁道数。 启动磁盘执行输入输出操作时，要把移动臂移动到指定的柱面，再等待指定扇区的旋转到磁头位置下，然后让指定的磁头进行读写，完成信息传送。因此，执行一次输入输出所花的时间有： 寻找时间——磁头在移动臂带动下移动到指定柱面所花的时间。

操作系统模拟进程调度算法

操作系统 ——项目文档报告 进程调度算法 专业： 班级： 指导教师： 姓名： 学号：

一、核心算法思想 1.先来先服务调度算法 先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。 2.短作业（进程）优先调度算法 短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。该算法对长作业不利，完全未考虑作业的紧迫程度。 3.高响应比优先调度算法 在批处理系统中，短作业优先算法是一种比较好的算法，其主要不足之处是长作业的运行得不到保证。如果我们能为每个作业引人动态优先权，并使作业的优先级随着等待时间的增加而以速率a提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的变化规律可描述为: 优先权=（等待时间+要求服务时间）/要求服务时间 即优先权=响应时间/要求服务时间 如果作业的等待时间相同，则要求服务的时间越短，其优先权越高，因而该算法有利于短作业。 当要球服务的时间相同时，作业的优先权决定于其等待时间，等待时间越长，优先权越高，因而它实现的是先来先服务 对于长作业，作业的优先级可以随着等待时间的增加而提高，当其等待时间足够长时，其优先级便可以升到很高，从而也可获得处理机。 4.时间片轮转算法 在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之，系统能在给定的时间内响应所有用户的请求。 二、核心算法流程图

模拟一种处理机调度算法

课程设计报告 设计名称：模拟实现一种处理机调度算法 学生姓名： xxx 专业：计算机科学与技术 班别： xxxxxxxx 学号： xxxxxx 指导老师： xxxxx 日期： 2014 年 6 月 20 日

初始条件： 1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。 2．实践准备：掌握一种计算机高级语言的使用。 要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求） 1．模拟进程调度，能够处理以下的情形： ⑴能够选择不同的调度算法（要求中给出的调度算法）； ⑵能够输入进程的基本信息，如进程名、优先级、到达 时间和运行时间等； ⑶根据选择的调度算法显示进程调度队列； ⑷根据选择的调度算法计算平均周转时间和平均带权周 转时间。 2．设计报告内容应说明： ⑴需求分析； ⑵功能设计（数据结构及模块说明）； ⑶开发平台及源程序的主要部分； ⑷测试用例，运行结果与运行情况分析； ⑸自我评价与总结： i）你认为你完成的设计哪些地方做得比较好或比较出 色； ii）什么地方做得不太好，以后如何改正；

iii）从本设计得到的收获（在编写，调试，执行过程中 的经验和教训）； iv）完成本题是否有其他方法（如果有，简要说明该方 法）； 进程调度模拟设计——先来先服务、优先级法1、背景： 当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。只要有两个或更多的进程处于就绪状态，这种情形就会发生。如果只有一个CPU可用，那么就必须选择下一个要运行的进程。在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。 进程调度的核心问题是采用什么样的算法把处理机分配给进程，好的算法将提高资源利用率，减少处理机的空闲时间，避免有些作业长期得不到相应的情况发生等，从而设计出受欢迎的操作系统。较常见的几种进程调度算法有：先来先服务调度算法；短作业优先调度算法；时间片轮转调度算法；优先级调度算法；高响应比优先算法和多级反馈队列调度算法等。 2.1设计目的 无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机

进程调度算法磁盘调度算法银行家算法操作系统课程设

操作系统课程设计 说明书 学院名称： 专业班级： 姓名： 学号： 2013年1月1日

评分标准 优秀：有完整的符合标准的文档，文档有条理、文笔通顺，格式正确，程序完全实现设计要求，独立完成； 良好：有完整的符合标准的文档，文档有条理、文笔通顺，格式正确；程序完全实现设计要求，独立完成，但存在少量错误； 中等：有完整的符合标准的文档，有基本实现设计方案的软件，设计方案正确； 及格：有完整的符合标准的文档，有基本实现设计方案的软件，设计方案基本正确； 不及格：没有完整的符合标准的文档，软件没有基本实现设计方案，设计方案不正确。没有独立完成，抄袭或雷同。 成绩评定为：。 指导教师： 年月日

目录 一．进程调度算法4-----23 页二．银行家算法24-----34 页三．磁盘调度算法35------46页

进程调度算法 1．设计目的 在多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略决定哪个进程优先占有处理机，因而必须解决进程调度的问题，进程调度算法就是要解决进程调度的问题。 2. 任务及要求 2.1 设计任务 设计程序来模拟进程的四种调度算法，模拟实现调度的基本功能。 2.2 设计要求 产生的各种随机数要加以限制，如alltime限制在40以内的整数。 进程的数量n不能取值过大。 3. 算法及数据结构 3.1算法的总体思想（流程） 每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段： （1）进程优先数ID，其中0为闲逛进程，用户进程的标识数为1，2，3…。 （2）进程优先级Priority，闲逛进程（idle）的优先级为0，用户进程的优 先级大于0，且随机产生，优先数越大，优先级越高。 （3）进程占用的CPU时间CPUtime，进程每运行一次，累计值等于4。 （4）进程总共需要运行时间Alltime，利用随机函数产生。 （5）进程状态，0：就绪态；1：运行态；2：阻塞态。 利用链表将数据连接起来，实现数据的存储。 3.2 链表模块 3.2.1 功能 实现链表的存储功能，以及实现存储的查找功能。

操作系统课程设计

课程设计说明书 （操作系统) 题目:进程调度 院系:计算机科学与工程学院 专业班级：信息安全１3—2 学号： 20１３302９xｘ 学生姓名: xｘ 指导教师：ｘｘ 2０１5年１2月 15日 ?安徽理工大学课程设计（论文)任务书 计算机科学与工程学院

安徽理工大学课程设计（论文)成绩评定表

摘要 现代计算机系统中,进程就是资源分配与独立运行得基本单位,就是操作系统得核心概念.因而,进程就成为理解操作系统如何实现系统管理得最基本，也就是最重要得概念。进程调度就是进程管理过程得主要组成部分,就是必然要发生得事件。 在现代操作系统中，进程得并发机制在绝大多数时候，会产生不断变化得进程就绪队列与阻塞队列。处于执行态得进程无论就是正常或非正常终止、或转换为阻塞状态，都会引发从就绪队列中,由进程调度选择一个进程进占C ＰU。 进程调度得核心就是进程调度得算法。在本课程设计中,用良好清晰得界面向用户展示了进程调度中得时间片轮转调度算法.在最终实现得成果中，用

户可指定需要模拟得进程数,CPU时间片与进程得最大执行时间,并且选择需要演示得算法，界面将会动态得显示进程调度过程及各个队列得变化。通过此进程调度模拟系统,用户可以对时间片轮转调度算法有进一步以及直观得了解。 关键词：进程，调度，PCB，时间片轮转?目录 1、设计目得................................................................................................................. 错误!未定义书签。 2、设计思路................................................................................................................. 错误!未定义书签。 3、设计过程................................................................................................................. 错误!未定义书签。 3、１流程图............................................................................................................. 错误!未定义书签。 3、2算法?错误!未定义书签。 3、3数据结构.......................................................................................................... 错误!未定义书签。 3、4源代码?错误!未定义书签。 4、实验结果及分析..................................................................................................... 错误!未定义书签。 4、1使用说明?错误!未定义书签。 4、2程序演示?错误!未定义书签。 5、实验总结................................................................................................................. 错误!未定义书签。 6、参考文献................................................................................................................. 错误!未定义书签。