先到先服务算法

① 先来先服务调度算法的思想是什么

先来先服务(FCFS: first come first service)总是把当前处于就绪队列之首的那个进程调度到运行状态。也就说，它只考虑进程进入就绪队列的先后，而不考虑它的下一个CPU周期的长短及其他因素。FCFS算法简单易行，但性能却不大好。

② 简单介绍一下先来先服务算法，不需要具体算法

先来先服务，意思和字面意思一样，谁先来先接待谁，后来的排队去。
就是个很朴素的算法思想。
比如进程调度，哪个进程先发出请求，处理器就处理哪个进程，其他进程根据请求的先后排队等待。

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

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

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

④ 作业调度算法的选择原则有哪几个

批处理作业的调度算法主要有以下几种：
①先来先服务算法。原则上按照作业进入输入井的次序调度，如果作业的资源得不到满足，将会推迟调度，它的资源得到满足的时候会优先被调度进来。
优点：具有一定的公平性。
缺点：系统的吞吐率低，平均周转时间长，有大作业到来的时，许多小作业推迟调度。
②计算时间短的作业优先．优先调度计算时间短的作业进行调度，资源不满足的情况下推迟调度。在这种调度算法下，要求用户要对作业的计算时间预先有一个估计，调度以此为依据。
优点：由于被选中的作业计算时间，所以不能尽快地完成并退出系统，降低了作业的平均等待时间，提高了系统的吞吐率。
缺点：大作业会不满意，而且极限情况下使得某些大作业始终得不到调度。
③响应比高者优先算法。该算法考虑了计算时间等待时间，既考虑了计算时间短的作业优先，又考虑了大作业长期等待的问题。所谓响应比是按照以下公式来定义的：
响应比R=等待时间/计算时间
这里的计算时间是估计的作业计算时间，从公式看，计算时间越短，响应比越高；而另一方面，大作业等待时间越长，响应比也会越大。一个作业完成以后，需要重新计算一下在输入井中的各个作业的响应比，最高的将优先调度。
④优先数调度算法。为每一个作业指定一个优先数，优先数高的作业先被调度。对于优先数相等的作业采用先来先服务的策略。优先数的制定原则是：作业的缓急程序，估计的计算时间，作业的等待时间，资源申请情况等因素综合考虑。
⑤均衡调度算法。使用不同资源的进程同时执行，减少作业等待同类设备而耗费的时间，加快作业的执行。

⑤ 先来先服务的基本思想

先来先服务的作业调度算法：优先从后备队列中，选择一个或多个位于队列头部的作业，把他们调入内存，分配所需资源、创建进程，然后放入“就绪队列”。
先来先服务的进程调度算法：从“就绪队列”中选择一个最先进入队列的进程，为它分配处理器，使之开始运行。

⑥ 用伪代码写出先到先服务的算法步骤

伪代码如下 INSERTION-SORT(A) 1forj← 2tolength[A] 2dokey←A[j] 3InsertA[j] into the sorted sequenceA[1..j-1]. 4i←j-1 5whilei>0 andA[i] >key 6doA[i+1] ←A[i] 7i←i-1 8A[i+1] ←key C语言代码如下 void insertion_sort(int array[],int first,int last) { int i,j; int temp; for (i = first+1; i<=last;i++) { temp = array[i]; j=i-1; //与已排序的数逐一比较，大于temp时，该数移后 while((j>=first) && (array[j] > temp)) { array[j+1] = array[j]; j--; } array[j+1] = temp; } }

⑦ 先来先服务(FCFS)调度算法 工作原理 优缺点

进程按到来的时间先后顺序依次被CPU处理。
优点：就是俗话说的“先来后到”。
缺点：如果先来的进程需要很长的处理时间，而后来的进程却很重要的。需要抢占CUP的时候，此调度算法就适用了。

⑧ 先来先服务算法(C语言版)

#include<stdio.h>
#include<stdlib.h>

typedef struct process_FCFS{
float arrivetime;//到达时间
float servetime;//服务时间
float finishtime;//完成时间
float roundtime;//周转时间
float daiquantime;//带权周转时间
struct process_FCFS *link;//结构体指针
}FCFS;
FCFS *p,*q,*head=NULL;
struct process_FCFS a[100];
//按到达时间进行冒泡排序

struct process_FCFS *sortarrivetime(struct process_FCFS a[],int n)
{
int i,j;
struct process_FCFS t;
int flag;
for(i=1;i<n;i++)
{
flag=0;
for(j=0;j<n-i;j++)
{
if(a[j].arrivetime>a[j+1].arrivetime)
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
flag=1;//交换
}
}
if(flag==0)//如果一趟排序中没发生任何交换，则排序结束
break;
}
return a;
}

//先来先服务算法

void print(struct process_FCFS a[],int n)
{
int i;
for(i=0;i<n;i++)
{
printf("到达时间：%f",a[i].arrivetime);
printf("服务时间：%f",a[i].servetime);

printf("完成时间：%f",a[i].finishtime);
printf("周转时间：%f",a[i].roundtime);
printf("带权周转时间：%f",a[i].daiquantime);
printf("\n");
}
}

void Fcfs(struct process_FCFS a[],int n)
{
int i;
a[0].finishtime=a[0].arrivetime+a[0].servetime;
a[0].roundtime=a[0].finishtime+a[0].arrivetime;
a[0].daiquantime=a[0].roundtime/a[0].servetime;
for(i=0;i<n;i++)
{
if(a[i].arrivetime<a[i-1].finishtime)
{
a[i].finishtime=a[i-1].finishtime+a[i].servetime;
a[i].roundtime=a[i].finishtime-a[i].arrivetime;
a[i].daiquantime=a[i].roundtime/a[i].servetime;
}
else
{
a[i].finishtime=a[i].arrivetime+a[i].servetime;
a[i].roundtime=a[i].finishtime-a[i].arrivetime;
a[i].daiquantime=a[i].roundtime/a[i].servetime;
}
}
printf("先来先服务\n");
print(a,n);
}
//主函数
void main()
{
int n,i;
printf("请输入有几个进程\n");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("arrivetime");
scanf("%f",&a[i].arrivetime);
printf("servetime");
scanf("%f",&a[i].servetime);
}
Fcfs(a,n);
}

⑨ CPU的调度算法:先来先服务、最短运行期、时间片轮转、优先权设置分别是什么意思

调度算法说的是现在有若干个进程（每个进程拥有自己的属性），算法根据它们的属性选择哪一个进程去执行。

先来先服务：按照进程来的时间早晚属性来判断，先来的先执行
最短：按照进程运行需要的时间长短属性来判断，最短的先执行
时间片轮转：和进程属性无关，每个进程都分配相同的时间去运行，轮着来
优先权设置：根据进程的优先级属性判断谁先执行，优先级是用户可以设定的
希望能够帮到你

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

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