本文目录一览：
- 1、如何理解先来先服务fcfs和短作业优先sjf进程调度算法
- 2、以下五个作业，fcfs sjf hrrn三种调度算法平均周转时间，高响应比怎么算
- 3、用C++编程实现两个调度算法（如SJF、时间片轮转法、优先权调度、、、）谢谢！
- 4、苹果7序列号C6KSJFV7HG7M的机型是正品吗，港版还是其他的？？
如何理解先来先服务fcfs和短作业优先sjf进程调度算法
先来先服务FCFS和短作业优先 和短作业优先SJF进程调度算法 先来先服务 和短作业优先 进程调度算法 1、实验目的 通过这次实验，加深对进程概念的理解，进一步掌握进程状态的 转变、进程调度的策略及对系统性能的评价方法。 2、需求分析 (1) 输入的形式和输入值的范围 输入值：进程个数Num 依次输入Num个进程的到达时间 依次输入Num个进程的服务时间 范围：0Num=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 hrrn三种调度算法平均周转时间，高响应比怎么算
作业调度算法 .
先来先服务（FCFS, First Come First Serve）是最简单的调度算法，按先后顺序进行调度。
定义：
按照作业提交或进程变为就绪状态的先后次序，分派CPU；
当前作业或进程占用CPU，直到执行完或阻塞，才出让CPU（非抢占方式）。
在作业或进程唤醒后（如I/O完成），并不立即恢复执行，通常等到当前作业或进程出让CPU。
适用场景：
比较有利于长作业，而不利于短作业。因为长作业会长时间占据处理机。
有利于CPU繁忙的作业，而不利于I/O繁忙的作业。
算法实现原理图：
2. 轮转法(Round Robin)
轮转法是让每个进程在就绪队列中的等待时间与享受服务的时间成正比例。
定义：
将系统中所有的就绪进程按照FCFS原则，排成一个队列。
每次调度时将CPU分派给队首进程，让其执行一个时间片。时间片的长度从几个ms到几百ms。
在一个时间片结束时，发生时钟中断。
调度程序据此暂停当前进程的执行，将其送到就绪队列的末尾，并通过上下文切换执行当前的队首进程。
进程可以未使用完一个时间片，就出让CPU（如阻塞）。
时间片长度的确定：
时间片长度变化的影响
过长－退化为FCFS算法，进程在一个时间片内都执行完，响应时间长。
过短－用户的一次请求需要多个时间片才能处理完，上下文切换次数增加，响应时间长。
对响应时间的要求：T(响应时间)=N(进程数目)*q(时间片)
就绪进程的数目：数目越多，时间片越小
系统的处理能力：应当使用户输入通常在一个时间片内能处理完，否则使响应时间，平均周转时间和平均带权周转时间延长。
算法实现原理图：
3. 多级反馈队列算法(Round Robin with Multiple Feedback)
多级反馈队列算法是轮转算法和优先级算法的综合和发展。
定义：
设置多个就绪队列，分别赋予不同的优先级，如逐级降低，队列1的优先级最高。每个队列执行时间片的长度也不同，规定优先级越低则时间片越长，如逐级加倍。
新进程进入内存后，先投入队列1的末尾，按FCFS算法调度；若按队列1一个时间片未能执行完，则降低投入到队列2的末尾，同样按FCFS算法调度；如此下去，降低到最后的队列，则按“时间片轮转”算法调度直到完成。
仅当较高优先级的队列为空，才调度较低优先级的队列中的进程执行。如果进程执行时有新进程进入较高优先级的队列，则抢先执行新进程，并把被抢先的进程投入原队列的末尾。
优点：
为提高系统吞吐量和缩短平均周转时间而照顾短进程。
为获得较好的I/O设备利用率和缩短响应时间而照顾I/O型进程。
不必估计进程的执行时间，动态调节
几点说明：
I/O型进程：让其进入最高优先级队列，以及时响应I/O交互。通常执行一个小时间片，要求可处理完一次I/O请求的数据，然后转入到阻塞队列。
计算型进程：每次都执行完时间片，进入更低级队列。最终采用最大时间片来执行，减少调度次数。
I/O次数不多，而主要是CPU处理的进程。在I/O完成后，放回优先I/O请求时离开的队列，以免每次都回到最高优先级队列后再逐次下降。
为适应一个进程在不同时间段的运行特点，I/O完成时，提高优先级；时间片用完时，降低优先级。
算法实现原理图：
4. 优先级法（Priority Scheduling）
优先级算法是多级队列算法的改进，平衡各进程对响应时间的要求。适用于作业调度和进程调度，可分成抢先式和非抢先式。
静态优先级：
作业调度中的静态优先级大多按以下原则确定：
由用户自己根据作业的紧急程度输入一个适当的优先级。
由系统或操作员根据作业类型指定优先级。
系统根据作业要求资源情况确定优先级。
进程的静态优先级的确定原则：
按进程的类型给予不同的优先级。
将作业的情态优先级作为它所属进程的优先级。
动态优先级：
进程的动态优先级一般根据以下原则确定：
根据进程占用有CPU时间的长短来决定。
根据就绪进程等待CPU的时间长短来决定。
5．短作业优先法（SJF, Shortest Job First）
短作业优先又称为“短进程优先”SPN(Shortest Process Next)；这是对FCFS算法的改进，其目标是减少平均周转时间。
定义：
对预计执行时间短的作业（进程）优先分派处理机。通常后来的短作业不抢先正在执行的作业。
SJF的特点：
(1) 优点：
比FCFS改善平均周转时间和平均带权周转时间，缩短作业的等待时间；
提高系统的吞吐量；
(2) 缺点：
对长作业非常不利，可能长时间得不到执行；
未能依据作业的紧迫程度来划分执行的优先级；
难以准确估计作业（进程）的执行时间，从而影响调度性能。
SJF的变型：
“最短剩余时间优先”SRT(Shortest Remaining Time)（允许比当前进程剩余时间更短的进程来抢占）
“最高响应比优先”HRRN(Highest Response Ratio Next)（响应比R = (等待时间 + 要求执行时间) / 要求执行时间，是FCFS和SJF的折衷）
6. 最高响应比优先法(HRN，Highest Response_ratio Next)
最高响应比优先法是对FCFS方式和SJF方式的一种综合平衡。FCFS方式只考虑每个作业的等待时间而未考虑执行时间的长短，而SJF方式只考虑执行时间而未考虑等待时间的长短。因此，这两种调度算法在某些极端情况下会带来某些不便。HRN调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。
响应比R定义如下： R =(W+T)/T = 1+W/T
其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。每当要进行作业调度时，系统计算每个作业的响应比，选择其中R最大者投入执行。这样，即使是长作业，随着它等待时间的增加，W / T也就随着增加，也就有机会获得调度执行。这种算法是介于FCFS和SJF之间的一种折中算法。由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF法，从而采用HRN方式时其吞吐量将小于采用SJF 法时的吞吐量。另外，由于每次调度前要计算响应比，系统开销也要相应增加。
用C++编程实现两个调度算法（如SJF、时间片轮转法、优先权调度、、、）谢谢！
#includestdio.h
#includetime.h
#includestdlib.h
/*********************以下是全局数据结构和变量***********************/
/*PCB 结构*/
struct PCB{
int pname;
int pri;
int runtime;
int waittime;
struct PCB *next;
}pcb[7];
/* 运行指针*/
struct PCB *running;
/*高优先级就绪队列头指针*/
struct PCB *Hready;
/*低优先级队列头指针*/
struct PCB *Lready;
/*等待队列头指针*/
struct PCB *wait;
int sig=0;
/**************************以下是函数说明****************************/
/*利用循环实现延迟*/
void delay();
/*模拟进程3－9*/
void proc(struct PCB *running);
/*将node插入到head所指示的队列的尾部*/
void InsertIntoQueueTail(struct PCB ** head,struct PCB *node);
/*进程调度函数*/
int proc_switch();
/*进程等待函数*/
void proc_wait();
/*进程唤醒函数*/
int proc_wakeup();
/************************以下是函数定义及注释************************/
/*主函数*/
main()
{
int i;
/*初始化，创建进程3－9，置低优先级，等待时间为0，
依次插入低优先级队列*/
for(i = 0;i 7;i++){
pcb[i].pname = i+3;
pcb[i].pri = 0;
pcb[i].waittime = 0;
InsertIntoQueueTail(Lready,pcb[i]);
}
/*等待队列和高优先级队列为空*/
wait = NULL;
Hready=NULL;
printf("\nThe process_switch begin:\n");
/*模拟进程调度开始*/
for(;;)
{
switch(sig){
case 0:/*无进程等待调度，打印信息并返回*/
if(!proc_switch())
{
printf("No Process to run,press any key to return:\n");
getchar();
}
break;
case 1:proc_wait();
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:proc(running);
break;
default:printf("\nerror!");
exit(-1);
}
}
}
/*功能：延迟一个时间片*/
/*入口参数：无*/
/*出口参数：无*/
void delay()
{
int i,j;
for(i=0;i20000;i++)
for(j=0;j10000;j++)
{
}
}
/*功能：进程3－9*/
/*入口参数：运行指针*/
/*出口参数：无*/
void proc(struct PCB * running)
{
int i;
srand( (unsigned)time( NULL ) );
/*显示当前运行的进程的id*/
printf("\nNow Process %d is running\n",running-pname);
/*当前进程执行running-runtime个时间片*/
for(i=running-runtime;i0;i--){
/*显示剩余的时间片*/
printf("%d time slice(s) left\n",i);
/*延迟*/
delay();
proc_wakeup();
/*产生一个1到1000的随机数，若该随机数小余100，当前进程等待，*/
if((rand()%1000+1)100){
printf("Process %d begins to wait.\n",running-pname);
sig=1;
return;
}
}
/*显示时间片耗尽，进程转为低优先级就绪状态*/
printf("Time slices for process %d exhausted.\n",running-pname);
InsertIntoQueueTail(Hready,running);
sig=0;
return;
}
/*功能：将一个节点插入队列尾部*/
/*入口参数：队列头指针地址head，待插入结点node*/
/*出口参数：无*/
void InsertIntoQueueTail(struct PCB **head,struct PCB *node)
{
struct PCB *p;
node-next=NULL;
/*被插入队列为空*/
if(*head==NULL){
*head=node;
return;
}
/*被插入队列不为空*/
else{
p=*head;
/*找到队列的最后一个结点*/
while(p-next!=NULL) p=p-next;
p-next=node;
}
}
/*功能：进程调度*/
/*入口参数：无*/
/*出口参数：若调度成功，返回1，否则返回0*/
int proc_switch()
{
/*若高优先级就绪队列和低优先级就绪队列均为空，则循环执行进程唤醒*/
while(Hready == NULL Lready == NULL)
if(!proc_wakeup()) return 0;
/*若高优先级就绪队列非空，则执行其第一个进程，分配2个时间片*/
if(Hready != NULL){
running = Hready;
Hready = Hready - next;
running-runtime = 2;
}
/*若高优先级就绪队列为空，则执行低优先级就绪队列的第一个进程，
分配5个时间片*/
else{
running = Lready;
Lready=Lready - next;
running - runtime = 5;
}
/*别调度进程的id赋给sig*/
sig = running - pname;
return 1;
}
/*功能：进程等待。将当前运行进程置高优先级，等待时间为20，
插入等待队列尾部*/
/*入口参数：无*/
/*出口参数：无*/
void proc_wait()
{
struct PCB *p;
running-pri=1;
running-waittime=20;
InsertIntoQueueTail(wait,running);
sig=0;
return;
}
/*功能：进程唤醒*/
/*入口参数：无*/
/*出口参数：若等待队列为空，则返回0，否则返回1*/
int proc_wakeup()
{
struct PCB *p,*last,*MoveToReady;
p = wait;
/*等待队列为空，返回0*/
if(p == NULL) return 0;
/*延迟*/
delay();
/*等待队列中每个进程的等待时间减1*/
while(p != NULL){
p - waittime -= 1;
p=p-next;
}
p=wait;
/*从等待队列中摘除等待时间为0的进程，插入到高优先级就绪队列的尾部*/
while(p!=NULL){
if(p - waittime == 0){
MoveToReady = p;
if (p == wait)
wait = p-next;
else
last - next = p-next;
p = p - next;
InsertIntoQueueTail(Hready,MoveToReady);
}
else{
p = p - next;
}
}
sig =0;
return 1;
}
苹果7序列号C6KSJFV7HG7M的机型是正品吗，港版还是其他的？？
除了序列号以外，还可以通过“型号”的后三位判断出售地区：
CH 为国行，最后两位是 ZP 的话代表销售地区为香港，也就是说该 iPhone 为港版，KH 是韩版，LL 是美版，TA 为台版。