试比较fcfs和sjf两种进程调度算法

他们的算法思想不同。

FCFS算法是指进程调度时是从就绪的进程队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行的一种调度算法。

SJF算法是指以作业的长短来计算优先级，作业越短，其优先级越高，越优先将他们调入内存运行。

是指自己在设计的任务完成到达的时间。另外调度算法是指：根据系统的资源分配策略所规定的资源分配算法。

一、先来先服务和短作业（进程）优先调度算法

1 先来先服务调度算法。先来先服务（FCFS）调度算法是一种最简单的调度算法，该算法既可用于作业调度， 也可用于进程调度。FCFS算法比较有利于长作业（进程），而不利于短作业（进程）。由此可知，本算法适合于CPU繁忙型作业， 而不利于I/O繁忙型的作业（进程）。

2 短作业（进程）优先调度算法。短作业（进程）优先调度算法（SJ/PF）是指对短作业或短进程优先调度的算法，该算法既可用于作业调度， 也可用于进程调度。但其对长作业不利；不能保证紧迫性作业（进程）被及时处理；作业的长短只是被估算出来的。

二、高优先权优先调度算法

1 优先权调度算法的类型。为了照顾紧迫性作业，使之进入系统后便获得优先处理，引入了最高优先权优先（FPF）调度算法。 此算法常被用在批处理系统中，作为作业调度算法，也作为多种 *** 作系统中的进程调度，还可以用于实时系统中。当其用于作业调度， 将后备队列中若干个优先权最高的作业装入内存。当其用于进程调度时，把处理机分配给就绪队列中优先权最高的进程。

这几个题是我这学期的 *** 作系统实验里面，变了两个月才弄出来的，现在跟你分享一下（运行过了 没问题的）

先来先服务：c语言编写的

#include <stdioh>

#include <malloch>

typedef struct jinchen  //定义结构体

{

char name[5];

int tijiaoshijian;

int reachtime;

int runtime;

int beirun;

int accomplishtime;

char state;

int flag;

struct jinchen next;

}PCB;

PCB finish,ready;//定义队列 一个完成一个就绪

int time=0;

int t=0;

int num;

void InitPcb()    //进程初始化

{

int i,j=0;

PCB p,q,l,m,k,n;

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

scanf("%d",&num);

ready=(PCB )malloc(sizeof(PCB));

ready->next=NULL;

finish=(PCB )malloc(sizeof(PCB));

finish->next=NULL;

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

l->next=NULL;

p=l;

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

{

q=(PCB )malloc(sizeof(PCB));

printf("\n进程号 %d:\n",i);

printf("请输入进程名：");

scanf("%s",q->name);

q->reachtime=0;

printf("请输入提交时间：");

scanf("%d",&(q->tijiaoshijian));

printf("请输入运行时间：");

scanf("%d",&(q->runtime));

q->beirun=q->runtime;

q->state='R';

q->flag=0;

if(i!=0)       //链接就绪进程

{

//q->next=NULL;

q->next=p->next;

p->next=q;

p=p->next;

}

else    //第一个进程插入就绪队列

{

p->next=q;

p=p->next;

p->next=NULL;

}

}

p=l->next;

k=ready;

for(i=0;i<num;i++)   //按照提交时间排序

{

q=l->next;

t=1000;

while(q!=NULL)

{

if(q->tijiaoshijian<t&&q->flag==0)

{

t=q->tijiaoshijian;

m=(PCB )malloc(sizeof(PCB));

m->next=NULL;

m->accomplishtime=q->accomplishtime;

m->beirun=q->beirun;

m->flag=q->flag;

for(j=0;j<5;j++)

m->name[j]=q->name[j];

m->reachtime=q->reachtime;

m->runtime=q->runtime;

m->state=q->state;

m->tijiaoshijian=q->tijiaoshijian;

n=q;

}

q=q->next;

}

p=p->next;

n->flag=1;

m->flag=1;

k->next=m;

k=k->next;

}

k->next=NULL;

}

void display()   //函数作用：计算和显示相关输出

{

PCB p;

int m,n=0,k=0,l;

p=finish->next;

while(p!=NULL)

{

printf("进程名 :%s",p->name);

m=p->accomplishtime-p->tijiaoshijian;

printf("周转时间:%d",m);

l=m/(p->beirun);

printf("带权周转时间:%d",l);

printf("\n");

n=m+n;

k=l+k;

p=p->next;

}

printf("平均周转时间:%d\n",n/num);

printf("平均带权周转时间:%d\n",k/num);

}

void Use()//进程调用

{

int j;

PCB p=ready->next,k=ready,q,n=finish;

while(k->next!=NULL)

{

p=ready->next;

for(j=0;j<num&&p!=NULL;j++)

{

time++;

//printf("%d\n\n",++t);

if(p->reachtime==0)

p->reachtime=time;

if(p->state!='C')

{

printf("正在运行:%s\n",p->name);

p->runtime--;

if(p->runtime!=0)    //进程没有运行完，放入队列最后

{

q=p;

while(q->next!=NULL)

q=q->next;

ready->next=p->next;

q->next=p;

p=ready->next;

q=q->next;

q->next=NULL;

}

else    //进程运行完，放入完成队列

{

p->state='C';

printf("%s进程完成\n",p->name);

p->accomplishtime=time;

n->next=p;

n=p;

ready->next=p->next;

p->next=NULL;

}

}

}

}

}

int main()

{

PCB p;

InitPcb();

Use();

display();

p=finish->next;

printf("运行完毕!说明：已运行完成的进程放入完成队列，未运行完成的进程放在队列最后");

}

运行结果见图

按最高优先级算法：C++程序

#include <stdioh>

#include <stdlibh>

#include <conioh>

#define getpch(type) (type)malloc(sizeof(type))

struct pcb{

char name[5];

char state;

int super;

int needtime;

int rtime;

int tijiaotime;

int starttime;

int ftime;

int zztime;

int dzztime;

struct pcb link;

}ready=NULL, p;

typedef struct pcb PCB;

float pzztime=0;

float pdzztime=0;

int n;

int time=20;

void sort()

{

PCB first, second;

int insert=0;

if((ready==NULL)||((p->super)<(ready->super)))

{

p->link=ready;

ready=p;

}

else

{

first=ready;

second=first->link;

while(second!=NULL)

{

if((p->super)<(second->super))

{

p->link=second;

first->link=p;

second=NULL;

insert=1;

}

else

{

first=first->link;

second=second->link;

}

}

if(insert==0) first->link=p;

}

}

void input()

{

int i;

PCB q;

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

scanf("%d",&n);

for(i=0;i<n;i++)

{

printf("\n第%d个进程:\n",i);

p=getpch(struct pcb);

printf("\n 进程名:");

scanf("%s",&p->name);

printf("\n 优先级:");

scanf("%d",&p->super);

printf("\n 运行时间:");

scanf("%d",&p->needtime);

printf("\n提交时间:");

scanf("%d",&p->tijiaotime);

p->rtime=0;

p->state='R';

p->link=NULL;

sort();

}

q=ready;

}

int space()

{

int l=0;

PCB pr=ready;

while(pr!=NULL)

{

l++;

pr=pr->link;

}

return(l);

}

void disp(PCB p2)

{

time = p2->tijiaotime > time p2->tijiaotime:time;

p2->starttime=time;

time+=p2->needtime;

p2->state='R';

p2->ftime=time;

p2->zztime=p2->ftime-p2->tijiaotime;

p2->dzztime=p2->zztime/p2->needtime;

pzztime=p2->zztime+pzztime;

pdzztime=p2->dzztime+pdzztime;

printf("周转时间:%d\n",p->zztime);

printf("带权周转时间为 %d\n",p->dzztime);

}

void destroy()

{

free(p);

}

void running()

{

p->rtime=p->rtime+1;

if(p->rtime==p->needtime)

{ p->state='C';

printf("%s",p->name);

printf("运行完毕\n");

disp(p);

destroy();

}

else

{

(p->super)++;

sort();

printf("正在运行进程%s\n",p->name);

}

}

void main()

{

int len,h=0;

input();

len=space();

while((len!=0)&&(ready!=NULL))

{

h++;

p=ready;

ready=p->link;

p->link=NULL;

running();

}

pzztime=pzztime/n;

pdzztime=pdzztime/n;

printf("\n平均周转时间:%f\n平均带权周转时间为%f\n",pzztime,pdzztime);

}

这个是多道程序设计的典型题啊，同学把分给我啊。

1 1)总共花多少时间：15（P1）+5(P2)+5(P3) +5(P1)+5(P3) +10(P2)+10(P3)=55(ms)

2）图我就不画了，你可以横坐标和时间，纵坐标为调动进程。在上面计算时，我已经把它们执行的时间顺序给出来了，相信你肯定可以画出。

2 单道的话，总时间为：P1+P2+P3=30+30+35=95(ms)，可知节省40ms

先来先服务FCFS和短作业优先 和短作业优先SJF进程调度算法 先来先服务 和短作业优先 进程调度算法 1、实验目的 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的 转变、进程调度的策略及对系统性能的评价方法。 2、需求分析 (1) 输入的形式和输入值的范围 输入值：进程个数Num 依次输入Num个进程的到达时间 依次输入Num个进程的服务时间 范围：0<Num<=100 范围： 范围： 输入要使用的算法（1-FCFS，2-SJF） 范围：1或者2 输出的形式（ 表示变量） (2) 输出的形式（X表示变量） 时刻X：进程X开始运行。 其完成时间：X 周转时间：X 带权周转时 间：X …（省略（Num-1）个） 平均周转时间：X 平均带权周转时间：X (3) 程序所能达到的功能 输入进程个数Num，每个进程到达时间ArrivalTime[i]，服务时间 ServiceTime[i]。采用先来先服务FCFS或者短作业优先SJF进程调度算 法进行调度，计算每个进程的完成时间、周转时间和带权周转时间， 并且统计Num个进程的平均周转时间和平均带权周转时间。 3、概要设计 说明本程序中用到的所有抽象数据类型的定义、 主程序的流程以 及各程序模块之间的层次(调用)关系。 4、详细设计 5、调试分析 (1)调试过程中遇到的问题以及解决方法， (1)调试过程中遇到的问题以及解决方法，设计与实现的回顾讨 调试过程中遇到的问题以及解决方法 论和分析 1 ○ 开始的时候没有判断进程是否到达， 导致短进程优先算法运 开始的时候没有判断进程是否到达， 行结果错误，后来加上了判断语句后就解决了改问题。 行结果错误，后来加上了判断语句后就解决了改问题。 2 ○ 基本完成的设计所要实现的功能， 总的来说， FCFS编写容易， 基本完成的设计所要实现的功能， 总的来说， FCFS编写容易， 编写容易 SJF 需要先找到已经到达的进程， 需要先找到已经到达的进程， 再从已经到达的进程里找到进程服务时 间最短的进程，再进行计算。 间最短的进程，再进行计算。 (2)算 (2)算法的改进设想 改进： 改进：即使用户输入的进程到达时间没有先后顺序也能准确 的计算出结果。（就是再加个循环，判断各个进程的到达时间先后， 的计算出结果。（就是再加个循环，判断各个进程的到达时间先后， 。（就是再加个循环 组成一个有序的序列） 组成一个有序的序列） (3)经验和体会 (3)经验和体会 通过本次实验， 通过本次实验，深入理解了先来先服务和短进程优先进程调 度算法的思想，培养了自己的动手能力，通过实践加深了记忆。 度算法的思想，培养了自己的动手能力，通过实践加深了记忆。

以上就是关于试比较fcfs和sjf两种进程调度算法全部的内容，包括:试比较fcfs和sjf两种进程调度算法、进程调度算法到达时间怎么理解、进程调度模拟程序等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！