先来先服务fcfs调度算法

⑴ 操作系统，为什么先来先服务算法适用于cpu繁忙型，啥意思

因为CPU繁忙型进程即长时间占用cpu很少有I/O操作，一旦获得cpu，就会运行很长时间，就是会长时间占用cpu，而I/O繁忙型由于要频繁访问IO端口，每次访问都要放弃cpu，等I/O访问完后要重新等待下一次调度（此时排到了就绪队列的队尾），所以要等待很久才能重新被调度。因此先来先服务有利于cpu繁忙型而不利于I/O繁忙型。
纯手打，望采纳

⑵ 先来先服务调度算法。 优先级调度算法。 短作业优先调度算法 轮转调度算法 响应比高优先调度算法

你试一下

#include<stdio.h>
//using namespace std;
#define MAX 10
struct task_struct
{
char name[10]; /*进程名称*/
int number; /*进程编号*/
float come_time; /*到达时间*/
float run_begin_time; /*开始运行时间*/
float run_time; /*运行时间*/
float run_end_time; /*运行结束时间*/
int priority; /*优先级*/
int order; /*运行次序*/
int run_flag; /*调度标志*/
}tasks[MAX];
int counter; /*实际进程个数*/
int fcfs(); /*先来先服务*/
int ps(); /*优先级调度*/
int sjf(); /*短作业优先*/
int hrrn(); /*响应比高优先*/
int pinput(); /*进程参数输入*/
int poutput(); /*调度结果输出*/

void main()
{ int option;
pinput();
printf("请选择调度算法（0~4）:\n");
printf("1.先来先服务\n");
printf("2.优先级调度\n");
printf(" 3.短作业优先\n");
printf(" 4.响应比高优先\n");
printf(" 0.退出\n");
scanf("%d",&option);
switch (option)
{case 0:
printf("运行结束。\n");
break;
case 1:
printf("对进程按先来先服务调度。\n\n");
fcfs();
poutput();
break;
case 2:
printf("对进程按优先级调度。\n\n");
ps();
poutput();
break;
case 3:
printf("对进程按短作业优先调度。\n\n");
sjf();
poutput();
break;
case 4:
printf("对进程按响应比高优先调度。\n\n");
hrrn();
poutput();
break;
}
}
int fcfs() /*先来先服务*/
{
float time_temp=0;
inti;
intnumber_schel;
time_temp=tasks[0].come_time;
for(i=0;i<counter;i++)
{
tasks[i].run_begin_time=time_temp;
tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;
tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time;
number_schel=i;
tasks[number_schel].order=i+1;
}
return 0;
}

int ps() /*优先级调度*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
intmax_priority;
max_priority=tasks[i].priority;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].priority>tasks[i].priority)
{
max_priority=tasks[j].priority;
i=j;
}
j++;
} /*查找第一个被调度的进程*/
/*对第一个被调度的进程求相应的参数*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
max_priority=0;
for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if (tasks[j].priority>max_priority)
{
max_priority=tasks[j].priority;
number_schel=j;
}
} /*查找下一个被调度的进程*/
/*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;

}return 0;
}

int sjf() /*短作业优先*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
float run_time;
run_time=tasks[i].run_time;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].run_time<tasks[i].run_time)
{
run_time=tasks[j].run_time;
i=j;
}
j++;
} /*查找第一个被调度的进程*/
/*对第一个被调度的进程求相应的参数*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
for(j=0;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{run_time=tasks[j].run_time;number_schel=j;break;}
}

for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if(tasks[j].run_time<run_time)
{run_time=tasks[j].run_time;
number_schel=j;
}
}
/*查找下一个被调度的进程*/
/*对找到的下一个被调度的进程求相应的参数*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}

int hrrn() /*响应比高优先*/
{ int j,number_schel,temp_counter;
float temp_time,respond_rate,max_respond_rate;
/*第一个进程被调度*/
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
/*调度其他进程*/
while(temp_counter<counter)
{
max_respond_rate=0;
for(j=1;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time;
if (respond_rate>max_respond_rate)
{
max_respond_rate=respond_rate;
number_schel=j;
}
}
} /*找响应比高的进程*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].run_flag=1;
temp_counter+=1;
tasks[number_schel].order=temp_counter;
}
return 0;
}
int pinput() /*进程参数输入*/
{ int i;
printf("please input the processcounter:\n");
scanf("%d",&counter);

for(i=0;i<counter;i++)
{printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the name:\n");
scanf("%s",tasks[i].name);
printf("please input the number:\n");
scanf("%d",&tasks[i].number);
printf("please input the come_time:\n");
scanf("%f",&tasks[i].come_time);
printf("please input the run_time:\n");
scanf("%f",&tasks[i].run_time);
printf("please input the priority:\n");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0;
}
return 0;
}
int poutput() /*调度结果输出*/
{
int i;
float turn_round_time=0,f1,w=0;
printf("name number come_time run_timerun_begin_time run_end_time priority order turn_round_time\n");
for(i=0;i<counter;i++)
{
f1=tasks[i].run_end_time-tasks[i].come_time;
turn_round_time+=f1;
w+=(f1/tasks[i].run_time);
printf(" %s, %d, %5.3f, %5.3f, %5.3f, %5.3f, %d, %d,%5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1);
}
printf("average_turn_round_timer=%5.2f\n",turn_round_time/counter);
printf("weight_average_turn_round_timer=%5.2f\n",w/counter);
return 0;
}

⑶ 调度算法详细资料大全

作业系统管理了系统的有限资源，当有多个进程（或多个进程发出的请求）要使用这些资源时，因为资源的有限性，必须按照一定的原则选择进程（请求）来占用资源。这就是调度。目的是控制资源使用者的数量,选取资源使用者许可占用资源或占用资源。

基本介绍

• 中文名 ：调度算法
• 所属领域 ：作业系统

调度算法,评价因素,吞吐量,CPU利用率,周转时间,确定进程调度原则,调度算法分类,先来先服务(FCFS),轮转法(Round Robin),多级反馈伫列算法,linux进程调度算法,

调度算法

在作业系统中调度是指一种资源分配，因而调度算法是指：根据系统的资源分配策略所规定的资源分配算法。对于不同的的系统和系统目标，通常采用不同的调度算法，例如，在批处理系统中，为了照顾为数众多的段作业，应采用短作业优先的调度算法；又如在分时系统中，为了保证系统具有合理的回响时间，应当采用轮转法进行调度。目前存在的多种调度算法中，有的算法适用于作业调度，有的算法适用于进程调度；但也有些调度算法既可以用于作业调度，也可以用于进程调度。 通常将作业或进程归入各种就绪或阻塞伫列。 调度算法要求：高资源利用率、高吞吐量、用户满意等原则。 进程调度所采用的算法是与整个系统的设计目标相一致的： 1.批处理系统：增加系统吞吐量和提高系统资源的利用率; 2.分时系统：保证每个分时用户能容忍的回响时间。 3.实时系统：保证对随机发生的外部事件做出实时回响。

评价因素

吞吐量

单位时间内CPU完成作业的数量。

CPU利用率

从0%～100%。

周转时间

评价批处理系统的性能指标。 Ti = 作业完成时刻 － 作业提交时刻

确定进程调度原则

在系统角度来说，公平性：每个进程（不论优先权）都有机会被运行；较大的吞吐量。 用户角度：及时性：回响速度要快；较短的周转时间：不应当让用户等待时间过长。

调度算法分类

先来先服务(FCFS)

先来先服务（FCFS, First Come First Serve）是最简单的调度算法，按先后顺序进行调度。 1. FCFS算法 按照作业提交或进程变为就绪状态的先后次序，分派CPU； 当前作业或进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。 在作业或进程唤醒后（如I/O完成），并不立即恢复执行，通常等到当前作业或梁兆进程出让CPU。最简单的算法。 2. FCFS的特点 比较有利于长作业，而不利于短作业。 有利于CPU繁忙的作业，而不利于I/O繁忙的作业。

轮转法(Round Robin)

轮转法(Round Robin)是让每个进程在就绪伫列中的等待时间与享受服务的时间成正比例。 1. 轮转法 将系统中所有的就绪进程按照FCFS原则，排成一个伫列。 每次调度时将CPU分派给队碧渣戚首进程，让其执行一个时间片。时间片的长度从几个ms到几百ms。 在一个时间片结束时，发生时钟中断。 调度程式据此暂停当前进程的执行，将其送到就绪伫列的末尾，并通过上下文切换执行当前的队首进程。? 进程可以未使用完一个时间片，就出让CPU（如阻塞）。 2. 时间片长度的确定 时间片长度变化的影响2 过长－>退化为FCFS算法，进程在一个时间片内都执行完，回响时间长。2 过短－>用户的一次请求需要多个时间片才能处理完，上下文切换次数增加，回响时间长。 对回响时间的要求：T(回响悔陵时间)=N(进程数目)*q(时间片) 就绪进程的数目：数目越多，时间片越小 系统的处理能力：应当使用户输入通常在一个时间片内能处理完，否则使回响时间，平均周转时间和平均带权周转时间延长。

多级反馈伫列算法

多级反馈伫列算法时间片轮转算法和优先权算法的综合和发展。优点：2 为提高系统吞吐量和缩短平均周转时间而照顾短进程。2 为获得较好的I/O设备利用率和缩短回响时间而照顾I/O型进程。2 不必估计进程的执行时间，动态调节。 1. 多级反馈伫列算法2 设定多个就绪伫列，分别赋予不同的优先权，如逐级降低，伫列1的优先权最高。每个伫列执行时间片的长度也不同，规定优先权越低则时间片越长，如逐级加倍。2 新进程进入记忆体后，先投入伫列1的末尾，按FCFS算法调度；若按伫列1一个时间片未能执行完，则降低投入到伫列2的末尾，同样按FCFS算法调度；如此下去，降低到最后的伫列，则按“时间片轮转”算法调度直到完成。2 仅当较高优先权的伫列为空，才调度较低优先权的伫列中的进程执行。如果进程执行时有新进程进入较高优先权的伫列，则抢先执行新进程，并把被抢先的进程投入原伫列的末尾。 2. 几点说明 I/O型进程：让其进入最高优先权伫列，以及时回响I/O互动。通常执行一个小时间片，要求可处理完一次I/O请求的数据，然后转入到阻塞伫列。 计算型进程：每次都执行完时间片，进入更低级伫列。最终采用最大时间片来执行，减少调度次数。 I/O次数不多，而主要是CPU处理的进程。在I/O完成后，放回优先I/O请求时离开的伫列，以免每次都回到最高优先权伫列后再逐次下降。2为适应一个进程在不同时间段的运行特点，I/O完成时，提高优先权；时间片用完时，降低优先权。 3.shortest job next 系统计算程式调用的时间，时间最短的先执行。

linux进程调度算法

linux核心的三种调度方法： 1. SCHED_OTHER 分时调度策略， 2. SCHED_FIFO实时调度策略，先到先服务 3. SCHED_RR实时调度策略，时间片轮转 实时进程将得到优先调用，实时进程根据实时优先权决定调度权值，分时进程则通过nice和counter值决 定权值，nice越小，counter越大，被调度的机率越大，也就是曾经使用了cpu最少的进程将会得到优先调 度。 SHCED_RR和SCHED_FIFO的不同： 当采用SHCED_RR策略的进程的时间片用完，系统将重新分配时间片，并置于就绪伫列尾。放在伫列 尾保证了所有具有相同优先权的RR任务的调度公平。 SCHED_FIFO一旦占用cpu则一直运行。一直运行直到有更高优先权任务到达或自己放弃。 如果有相同优先权的实时进程（根据优先权计算的调度权值是一样的）已经准备好，FIFO时必须等待该 进程主动放弃后才可以运行这个优先权相同的任务。而RR可以让每个任务都执行一段时间。 SHCED_RR和SCHED_FIFO的相同点： SHCED_RR和SHCED_FIFO都只用于实时任务。 创建时优先权大于0(1-99)。 按照可抢占优先权调度算法进行。 就绪态的实时任务立即抢占非实时任务。 所有任务都采用linux分时调度策略时。 1. 创建任务指定采用分时调度策略，并指定优先权nice值(-20~19)。 2. 将根据每个任务的nice值确定在cpu上的执行时间(counter)。 3. 如果没有等待资源，则将该任务加入到就绪伫列中。 4. 调度程式遍历就绪伫列中的任务，通过对每个任务动态优先权的计算(counter+20-nice)结果，选择 计算结果最大的一个去运行，当这 个时间片用完后(counter减至0)或者主动放弃cpu时，该任务将被放在 就绪伫列末尾(时间片用完)或等待伫列(因等待资源而放弃cpu)中。 5. 此时调度程式重复上面计算过程，转到第4步。 6. 当调度程式发现所有就绪任务计算所得的权值都为不大于0时，重复第2步。 所有任务都采用FIFO时: 1. 创建进程时指定采用FIFO，并设定实时优先权rt_priority(1-99)。 2. 如果没有等待资源，则将该任务加入到就绪伫列中。 3. 调度程式遍历就绪伫列，根据实时优先权计算调度权值(1000+rt_priority),选择权值最高的任务使用 cpu，该FIFO任务将一直占有cpu直到有优先权更高的任务就绪(即使优先权相同也不行)或者主动放弃(等 待资源)。 4. 调度程式发现有优先权更高的任务到达(高优先权任务可能被中断或定时器任务唤醒，再或被当前运行 的任务唤醒，等等)，则调度程式立即在当前任务 堆叠中保存当前cpu暂存器的所有数据，重新从高优先权 任务的堆叠中载入暂存器数据到cpu，此时高优先权的任务开始运行。重复第3步。 5. 如果当前任务因等待资源而主动放弃cpu使用权，则该任务将从就绪伫列中删除，加入等待伫列，此时 重复第3步。 所有任务都采用RR调度策略时 1. 创建任务时指定调度参数为RR，并设定任务的实时优先权和nice值(nice值将会转换为该任务的时间片 的长度)。 2. 如果没有等待资源，则将该任务加入到就绪伫列中。 3. 调度程式遍历就绪伫列，根据实时优先权计算调度权值(1000+rt_priority),选择权值最高的任务使用 cpu。 4. 如果就绪伫列中的RR任务时间片为0，则会根据nice值设定该任务的时间片，同时将该任务放入就绪队 列的末尾。重复步骤3。 5. 当前任务由于等待资源而主动退出cpu，则其加入等待伫列中。重复步骤3。 系统中既有分时调度，又有时间片轮转调度和先进先出调度 1. RR调度和FIFO调度的进程属于实时进程，以分时调度的进程是非实时进程。 2. 当实时进程准备就绪后，如果当前cpu正在运行非实时进程，则实时进程立即抢占非实时进程。 3. RR进程和FIFO进程都采用实时优先权做为调度的权值标准，RR是FIFO的一个延伸。FIFO时，如果两 个进程的优先权一样，则这两个优先 级一样的进程具体执行哪一个是由其在伫列中的未知决定的，这样导 致一些不公正性(优先权是一样的，为什么要让你一直运行?),如果将两个优先权一样的任务 的调度策略都 设为RR,则保证了这两个任务可以循环执行，保证了公平。

⑷ 操作系统先进先出(FIFO)和先来先服务(FCFS)有什么区别

1.先来先服务调度算法（FCFS）:就是按照各个作业进入系统的自然次序来调度作业。这种调度算法的优点是实现简单，公平。其缺点是没有考虑到系统中各种资源的综合使用情况，往往使短作业的用户不满意，因为短作业等待处理的时间可能比实际运行时间长得多。

2.先进先出算法(FIFO)：按照进程进入就绪队列的先后次序来选择。即每当进入进程调度，总是把就绪队列的队首进程投入运行。

⑸ 进程调度算法1——FCFS、SJF、HNNR

  进程的调度方式有两种： 非剥夺调度方式（非抢占式）和剥夺调度方式（抢占方式）。
  非抢占式：只允许进程主动放弃处理机。如进程运行结束、异常结束或主动请求I/O阻塞。在运行的过程中即使有更紧迫的任务到达，当前进程依然会继续使用处理机，直到该进程终止或主动要求进入阻塞态。
  抢占式：当一个进程正在处理机上执行时，如果有一个更重要更紧迫的进程需要处理机，则立即暂停正在执行的进程，将处理机分配给更重要更紧迫的那个进程。
  下面介绍适用于早期操作系统几种进程调度的算法

  先来先服务（FCFS）：按照到达的先后顺序调度，事实上就是等待时间越久的越优先得到服务。
  下面表示按照先来先服务算法的执行顺序

  计算进程的几个衡量指标：

  短作业优先算法是非抢占式的算法，但是也有抢占式的版本—— 最短剩余时间优先算法（STRN,Shortest Remaining Time Next） 。
  用于进程的调度算法称为短进程优先调度算法（SPF,Shortest Process First）。

  短作业/进程优先调度算法：每次调度时选择当前已到达且运行时间最短的作业/进程.。

  因为进程1最先达到，此时没有其他线程，所以进程1先被服务。当进程1运行完后，进程2和3已经到达，此时进程3需要的运行时间比进程2少，所以进程3先被服务…
  计算进程的几个衡量指标：

  最短剩余时间优先算法：每当有进程 加入就绪队列改变时就需要调度 ，如果新到达的进程的所需的运行时间比当前运行的进程剩余时间更短，则由新进程抢占处理机，当前运行进程重新回到就绪队列。此外，当一个 进程完成时也需要调度 。

通过比较上面三组的平均周转时间、平均带权周转时间和平均等待时间可以看出，短作业优先算法可以减少进程的等待时间，对短作业有利。

  高响应比优先算法： 非抢占式的调度算法 ，只有当前运行的进程主动放弃CPU时（正常/异常完成、或主动阻塞），才需要进行调度，调度时计算所有就绪进程的相应比，选响应比最高的进程上处理机。

   响应比 = （等待时间 + 运行时间）/ 运行时间

  上面的三种调度算法一般适用于 早期的批处理系统 ，没有考虑响应时间也不区分任务的紧急程度。因此对用户来说交互性差。

  如发现错误，请指正！！！

⑹ 实时操作系统常用任务调度算法有哪些

实时操作系统常用任务调度算法有哪些
操作系统常用的批处理作业调度算法
1．先来先服务调度算法
先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
2．短作业(进程)优先调度算法