在rr算法

Ⅰ 模拟短作业优先算法、时间片轮转算法（RR）和优先数算法的执行情况

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define LENsizeof(struct job)

struct job
{
char name[2];
int cometime;
int runtime;
int priority;
int finishtime;
int state;
struct job *next;
};

void readtxt();
void SJF();
void (structjob *,struct job *);
void RR(int);
void FPF();
void print1(structjob *);
void print2(structjob *);

int n=0;
struct job*head=NULL;
struct job*end=NULL;
FILE*fp=NULL;

void main()
{
if((fp=fopen("JOB1.txt","rb"))==NULL){
printf("can not find file\n");
exit(0);
}
while(!feof(fp)){
readtxt();
}
fclose(fp);

int x,y;
printf("请选择进程调度算法：\n");
printf("1.短作业优先算法 2.时间片轮转算法 3.优先数算法\n");
printf("选择序号：");
scanf("%d",&x);
if((x!=1)&&(x!=2)&&(x!=3))printf("序号不存在！\n");
else{
switch(x){
case 1: SJF(); break;
case 2: {
printf("输入时间片：");
scanf("%d",&y);
RR(y);
break;
}
case 3: FPF(); break;
}
}
}

void readtxt(){
struct job *p1;
p1=(struct job *)malloc(LEN);
fscanf(fp,"%s %d %d%d",(*p1).name,&((*p1).cometime),&((*p1).runtime),&((*p1).priority));
(*p1).state=0;
(*p1).finishtime=0;
if(n==0){
head=p1;
end=p1;
(*end).next=NULL;
n++;
}
else{
(*end).next=p1;
end=p1;
(*end).next=NULL;
n++;
}
}

void SJF(){
struct job *shead,*send,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).runtime<(*p1).runtime)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
shead=p;
send=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).runtime<(*p1).runtime)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*send).next=p;
send=p;
}
(*send).next=NULL;
printf("%s\n","短作业优先算法执行结果：");
printf("%s\n","进程执行顺序 周转时间");
print1(shead);
}

void RR(intpertime){
structjob *rhead,*rend,*rrhead,*rrend,*p1,*p2,*p;
int i,curtime=0,m=0,temp1=0,temp2;
while(m!=n){
p1=head;
temp2=temp1;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).runtime!=0)&&((*p1).state!=1)){temp1++;break;}
else p1=(*p1).next;
}
if(p1!=NULL){
p2=(*p1).next;
for(i=i+1;i<n;i++){
if((((*p2).cometime<(*p1).cometime)&&((*p2).runtime!=0)&&((*p2).state!=1))||
(((*p2).cometime==(*p1).cometime)&&((*p2).priority<(*p1).priority)&&((*p2).runtime!=0)&&((*p2).state!=1)))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
}

if(temp2!=temp1){
(*p1).state=1;
p=(struct job *)malloc(LEN);
(p,p1);
if(temp1==1) {rhead=p;rend=p;}
else{
(*rend).next=p;
rend=(*rend).next;
}
}
else{
if((temp1==1)&&(m==0)){
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
}
p=(struct job *)malloc(LEN);
(p,rhead);
rrhead=p;
rrend=p;
}
else{
if(strcmp((*rhead).name,(*rrend).name)==0){
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}

}
else{
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}
}
}
}
}
(*rrend).next=NULL;
printf("%s%d%s\n","时间片轮转算法执行结果(时间片",pertime,")：");
print2(rrhead);
}

void FPF(){
structjob *fhead,*fend,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).priority<(*p1).priority)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
fhead=p;
fend=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).priority<(*p1).priority)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*fend).next=p;
fend=p;
}
(*fend).next=NULL;
printf("%s\n","最高优先权优先算法执行结果(非抢占方式)：");
printf("%s\n","进程执行顺序 周转时间");
print1(fhead);
}

void (structjob *p,struct job *p1){
strcpy((*p).name,(*p1).name);
(*p).cometime=(*p1).cometime;
(*p).runtime=(*p1).runtime;
(*p).priority=(*p1).priority;
(*p).finishtime=(*p1).finishtime;
(*p).state=(*p1).state;
}

void print1(structjob *p){
while(p!=NULL){
printf("%-14s%d\n",(*p).name,(*p).finishtime-(*p).cometime);
p=(*p).next;
}
}

void print2(structjob *p){
struct job *head;
head=p;
printf("%s\n","进程执行顺序");
while(head!=NULL){
printf("%3s",(*head).name);
head=(*head).next;
}
printf("\n%s\n","进程周转时间");
head=p;
while(head!=NULL){
if(((*head).finishtime-(*head).cometime)>0)
printf("%-4s%d\n",(*head).name,(*head).finishtime-(*head).cometime);
head=(*head).next;
}
}

网上找的，自己看着办

Ⅱ 使用RR轮询算法,需要配置哪个文件

需要用辅助的数组存储信息之类的。
RR算法用队列直接模拟是相对很简单的，也很适合在考试时使用，但是其它的调度算法就不一定了，需要用辅助的数组存储信息之类的，符合原理地适时调整。
换进程。该算法中，将一个较小时间单元定义为时间量或时间片。时间片的大小通常为10-100ms。就绪队列作为循环队列。CPU调度程序循环整个就绪队列，为每个进程分配不超过一个时间片的CPU。为了实现RR调度，我们再次将就绪队列视为进程的FIFO队列。新进程添加到就绪队列的尾部。CPU调度程序从就绪队列中选择第一个进程，将定时器设置在一个时间片后中断，最后分派这个进程。接下来，有两种情况可能发生。进程可能只需少于时间片的CPU执行。对于这种情况，进程本身会自动释放CPU。调度程序接着处理就绪队列的下一个进程。否则，如果当前运行进程的CPU执行大于一个时间片，那么定时器会中断，进而中断操作系统。然后，进行上下文切换，再将进程加到就绪队列的尾部，接着CPU调度程序会选择就绪队列内的下一个进程。不过，采用RR策略的平均等待时间通常较长。假设有如下一组进程，它们在时间0到达，其CPU执行以ms计。

Ⅲ RR的分类

为了改进RR算法的时延特性和其在变长分组环境下的不公平性，人们又提出了一些改进算法，如加权轮询（WRR，Weight RR），差额轮询（DRR，Defict RR），紧急轮询（URR，Urgency-based RR）。这些算法都力图在尽量保持RR算法实现简单性的同时，从不同的方面改进RR算法的时延特性和其在可变长分组环境下的不公平性。 URR算法是为改善RR算法时延特性而提出的另一种算法。URR个紧急性指数算法为每个队列分配U；在每个调度循环前，算法首先计算各队列的U值，然后按照U的大小顺序为各队列提供服务。尽管URR算法改善了时延特性，但其原有的公平性问题仍然存在。

Ⅳ 考虑一种RR(时间片轮转)调度算法的变种,算法中就绪队列中存放的是指向各个进程控

#include “stdio.h”
#define running 1 // 用running表示进程处于运行态
#define aready 2 // 用aready表示进程处于就绪态
#define blocking 3 // 用blocking表示进程处于阻塞态
#define sometime 5 // 用sometime表示时间片大小
#define n 10 //假定系统允许进程个数为n
struct
{
int name; //进程标识符
int status; //进程状态
int ax,bx,cx,dx ; //进程现场信息，通用寄存器内容
int pc ; //进程现场信息，程序计数器内容
int psw; //进程现场信息，程序状态字内容
int next; //下一个进程控制块的位置
}pcbarea[n]; //模拟进程控制块区域的数组
int PSW, AX,BX,CX,DX , PC ,TIME ; //模拟寄存器
int run; //定义指向正在运行进程的进程控制块的指针
struct
{
int head;
int tail;
}ready; //定义就绪队列的头指针head和尾指针tail
int pfree; //定义指向空闲进程控制块队列的指针

scheling( ) //进程调度函数
{
int i;
if (ready.head==-1) //空闲进程控制块队列为空，退出
{
printf(“无就绪进程\n”);
return;
}
i=ready.head; //就绪队列头指针赋给i
ready.head=pcbarea[ready.head].next; //就绪队列头指针后移
if(ready.head==-1) ready.tail=-1; //就绪队列为空，修正尾指针ready.tail
pcbarea[i].status=running; //修改进程控制块状态
TIME=sometime; //设置相对时钟寄存器
//恢复该进程现场信息
AX=pcbarea[run].ax;
BX=pcbarea[run].bx;
CX=pcbarea[run].cx;
DX=pcbarea[run].dx;
PC=pcbarea[run].pc;
PSW=pcbarea[run].psw;
run=i;
}//进程调度函数结束

create(int x) //进程创建函数
{
int i;
if(pfree==-1) //空闲进程控制块队列为空
{
printf(“无空闲进程控制块，进程创建失败\n”);
return;
}
i=pfree; //取空闲进程控制块队列的第一个
pfree=pcbarea[pfree].next; // pfree后移
//填写该进程控制块的内容
pcbarea[i].name=x;
pcbarea[i].status=aready;
pcbarea[i].ax=x;
pcbarea[i].bx=x;
pcbarea[i].cx=x;
pcbarea[i].dx=x;
pcbarea[i].pc=x;
pcbarea[i].psw=x;
if (ready.head!=-1) //就绪队列不为空时，挂入就绪队列的方式
{
pcbarea[ready.tail].next=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
else //就绪队列为空时，挂入就绪队列的方式
{
ready.head=i;
ready.tail=i;
pcbarea[ready.tail].next=-1;
}
}//进程创建函数结束

main()
{ //系统初始化
int num,i,j;
run=ready.head=ready.tail =-1;
pfree=0;
for(j=0;j<n-1;j++)
pcbarea[j].next=j+1;
pcbarea[n-1].next=-1;
printf(“输入进程编号（避免编号冲突，以负数输入结束，最多可以创建10个进程）：\n”);
scanf(“%d”,num);
while(num>=0)
{
create(num) ;
scanf(“%d”,num) ;
}
scheling(); //进程调度
if(run!=-1)
{
printf(“进程标识符 进程状态 寄存器内容：ax bx cx dx pc psw:\n”);
printf(“%8d%10d%3d%3d%3d%3d%3d%3d\n”, pcbarea[run].name, pcbarea[run].status, pcbarea[run].ax, pcbarea[run].bx, pcbarea[run].cx, pcbarea[run].dx, pcbarea[run].pc, pcbarea[run].psw);
}
}//main()结束
我用的是vc++6.0的，你可以试试，有不懂得在和我交流吧

Ⅳ 时间片轮转算法（RR）能不能用在作业调度上还是只能用在进程调度上

导师给出的答案是不能，但是吧友似乎有一些别的看法。
先来看作业调度的定义，高级调度又称长程调度或作业调度，他的调度对象是作业。主要功能是根据算法，决定将外存处于后备队列的哪几个作业调入内存，为他们创建进程，分配必要的资源，并将它们放入就绪队列。分时和实时系统不设置高级调度。
其次简单的叙述一下低级调度（进程调度）：对象为进程，功能是决定就绪队列中的哪个进程应获得处理机，并分配。
最后来看一下RR的核心，进程切换：在RR调度算法中，应在合适进行进程的切换，可分为两种情况：1，若一个时间片尚未用完，正在运行的进程便已经完成，立刻激活调度程序，将他从就绪队列中删除，再调度就绪队列中对手的进程运行，并启动一个新的时间片。2.在一个时间片用完时，计时调度器中断处理程序被激活。如果进程尚未运行完毕，调度程序将把它送往就绪队列的末尾。
可见，RR算法在切换进程时只涉及了就绪队列的c、a、o作，也就是只有低级调度参与，并没有从外存将作业调入内存，另外，RR算法常用于分时系统，分时系统也是不设置作业调度的。

Ⅵ 进程调度算法

FCFS调度算法属于不可剥夺算法。从表面上看，它对所有作业都是公平的，但若一个长作业先到达系统，就会使后面许多短作业等待很长时间，因此它不能作为分时系统和实时系统的主要调度策略。但它常被结合在其他调度策略中使用。例如，在使用优先级作为调度策略的系统中，往往对多个具有相同优先级的进程按FCFS原则处理。

FCFS调度算法的特点是算法简单，但效率低； 对长作业比较有利，但对短作业不利（相对SJF和高响应比）；

FCFS调度算法有利于CPU繁忙型作业，而不利于I/O繁忙型作业。

​ 短作业优先调度算法是一个非抢占策略，他的原则是下一次选择预计处理时间最短的进程，因此短进程将会越过长作业，跳至队列头。该算法即可用于作业调度，也可用于进程调度。 但是他对长作业不利，不能保证紧迫性作业（进程）被及时处理，作业的长短只是被估算出来的。

缺点：

该算法对长作业不利，SJF调度算法中长作业的周转时间会增加。更严重的是，如果有一长作业进入系统的后备队列，由于调度程序总是优先调度那些 (即使是后进来的）短作业，将导致长作业长期不被调度（“饥饿”现象，注意区分“死锁”。后者是系统环形等待，前者是调度策略问题）。

该算法完全未考虑作业的紧迫程度，因而不能保证紧迫性作业会被及时处理。

由于作业的长短只是根据用户所提供的估计执行时间而定的，而用户又可能会有意或无意地缩短其作业的估计运行时间，致使该算法不一定能真正做到短作业优先调度。

SJF调度算法的平均等待时间、平均周转时间最少。

高响应比优先调度算法既考虑作业的执行时间也考虑作业的等待时间，综合了先来先服务和最短作业优先两种算法的特点。

该算法中的响应比是指作业等待时间与运行比值，响应比公式定义如下：

响应比 =（等待时间+要求服务时间）/ 要求服务时间,即RR=（w+s）/s=1+w/s，因此 响应比一定是大于等于1的。

短作业与先后次序的兼顾，且不会使长作业长期得不到服务。

响应比计算系统开销，增加系统开销。

高响应比优先调度算法适合批处理系统，主要用于作业调度。

为了实现 RR 调度，我们将就绪队列视为进程的 FIFO 队列。新进程添加到就绪队列的尾部。CPU 调度程序从就绪队列中选择第一个进程，将定时器设置在一个时间片后中断，最后分派这个进程。

接下来，有两种情况可能发生。进程可能只需少于时间片的 CPU 执行。对于这种情况，进程本身会自动释放 CPU。调度程序接着处理就绪队列的下一个进程。否则，如果当前运行进程的 CPU 执行大于一个时间片，那么定时器会中断，进而中断操作系统。然后，进行上下文切换，再将进程加到就绪队列的尾部，接着 CPU 调度程序会选择就绪队列内的下一个进程。

采用 RR 策略的平均等待时间通常较长。

在 RR 调度算法中，没有进程被连续分配超过一个时间片的 CPU（除非它是唯一可运行的进程）。如果进程的 CPU 执行超过一个时间片，那么该进程会被抢占，并被放回到就绪队列。因此， RR调度算法是抢占的。

算法描述

1、进程在进入待调度的队列等待时，首先进入优先级最高的Q1等待。

2、首先调度优先级高的队列中的进程。若高优先级中队列中已没有调度的进程，则调度次优先级队列中的进程。例如：Q1,Q2,Q3三个队列，当且仅当在Q1中没有进程等待时才去调度Q2，同理，只有Q1,Q2都为空时才会去调度Q3。

3、对于同一个队列中的各个进程，按照FCFS分配时间片调度。比如Q1队列的时间片为N，那么Q1中的作业在经历了N个时间片后若还没有完成，则进入Q2队列等待，若Q2的时间片用完后作业还不能完成，一直进入下一级队列，直至完成。

4、在最后一个队列QN中的各个进程，按照时间片轮转分配时间片调度。

5、在低优先级的队列中的进程在运行时，又有新到达的作业，此时须立即把正在运行的进程放回当前队列的队尾，然后把处理机分给高优先级进程。换而言之，任何时刻，只有当第1~i-1队列全部为空时，才会去执行第i队列的进程（抢占式）。特别说明，当再度运行到当前队列的该进程时，仅分配上次还未完成的时间片，不再分配该队列对应的完整时间片。

Ⅶ 急求一个c语言程序后天就要用了麻烦各位好心高手帮帮忙。谢谢。

#include<reg51.h>
#define uchar unsigned char
#define uint unsigned int

uint Tcounetr=0;
unsigned long int mm=0;
sbit P1_6=P1^6;
sbit P1_7=P1^7;

uchar code table[]={0xc0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,}; //设置字符代码

delay(uint m) //延时1ms程序
{ uint i,j;
for(i=m;i>0;i--)
for(j=60;j>0;j--);
}

xian_shi() //显示程序
{ uchar ,shi,ge,xiaoshu;
unsigned long int k=14,h=36;
unsigned long int jj;
jj=mm*k*h;
=jj/1000000;
shi=jj%1000000/100000;
ge=jj%100000/10000;
xiaoshu=jj%10000/1000;

P2=0xE0;
P0=table[];
delay(1);
P2=0XF0;

P2=0xD0;
P0=table[shi];
delay(1);
P2=0XF0;

P2=0xB0;
P0=table[ge];
delay(1);
P2=0XF0;

P2=0x70;
P0=table[xiaoshu];
delay(1);
P2=0XF0;
}
timer_init() //定时器计数器初始化函数
{ EA=1;
ET0=1;
ET1=1;
TMOD=0X51;
TH0=0XB1;
TL0=0XE0;
TH1=0;
TL1=0;
TR0=1;
TR1=1;
}
main() //主函数
{
timer_init();
P0=0; //开始数码管不显示
while(1)
{
xian_shi();
delay(2); //数码管刷新时间单位毫秒
}
}
void timer0() interrupt 1 //定时器0中断
{ uchar a;
TR0=0;
TH0=0XB1;
TL0=0XE0;
Tcounetr++;
if(Tcounetr>=50)
{ TR1=0;
Tcounetr=0;
a=TH1;
mm=a*256+TL1;
if(mm>=1984)
if(mm>=3000)
P1_7=0,
P1_6=0;
else
P1_7=0;
else
P1=0XFF;
TH1=0;
TL1=0;
TR1=1;
}
TR0=1;
}
void timer1() interrupt 3 //计数器1中断时出错
{ TR1=0;
TR0=0;
mm=0;
TH0=0XB1;
TL0=0XE0;
TH1=0;
TL1=0;
TR0=1;
TR1=1;

Ⅷ RR是什么

R是电阻！！！！！！电阻！！！

Ⅸ 处理机调度可以分为

在多道程序设计系统中，内存中有多道程序运行，他们相互争夺处理机这一重要的资源。处理机调度就是从就绪队列中，按照一定的算法选择一个进程并将处理机分配给它运行，以实现进程并发地执行。
1.处理机调度的功能
一般情况下，当占用处理机的进程因为某种请求得不到满足二不得不放弃CPU进入等待状态时，或者当时间片到，系统不得不将CPU分配给就绪队列中另以进程的时候，都要引起处理机调度。除此之外，进程正常结束、中断处理等也可能引起处理机的调度。因此，处理机调度是操作系统核心的重要组成部分，它的主要功能如下：
（1）记住进程的状态，如进程名称、指令计数器、程序状态寄存器以及所有通用寄存器等现场信息，将这些信息记录在相应的进程控制块中。
（2）根据一定的算法，决定哪个进程能获得处理机，以及占用多长时间。
（3）收回处理机，即正在执行的进程因为时间片用完或因为某种原因不能再执行的时候，保存该进程的现场，并收回处理机。
处理机调度的功能中，很重要的一项就是根据一定算法，从就绪队列中选出一个进程占用CPU运行。可见，算法是处理机调度的关键。
2.处理机调度的性能准则
处理机调度，有许多不问的调度算法，不同的调度算法具有不同的特性。因此，再介绍算法之前，先介绍衡量一个算法的基本准则。
衡量喝比较调度算法性能优劣主要有一下几个因素：
（1）CPU利用率。CPU是计算机系统中最重要的资源，所以应尽可能使CPU保持忙，使这一资源利用率最高。
（2）吞吐量。CPU运行时表示系统正处于工作状态，工作量的大小是以每单位时间所完成的昨夜树木来描述的，这就叫吞吐量。
（3）周转时间。指从作业提交到作业完成所经过的时间，包括作业等待，在就绪队列中排队，在处理机上运行以及进行输入/输出操作所花时间的总和。
（4）等待时间。处理机调度算法实际上并不影响作业执行或输入/输出操作的时间，只影响作业在就绪队列中等待所花的时间。因此，衡量一个调度算法优劣常常简单的考察等待时间。
（5）响应时间。指从作业提交到系统作出相应所经过的时间。在交互式系统中，作业的周转时间并不一定是最好的衡量准则，因此，常常使用另一种度量准则，即相应时间。从用户观点看，相应时间应该快一点好，但这常常要牺牲系统资源利用率为代价。
3.处理机调度算法
1）先来先服调度算法（FIFO）
这是最简单的处理机调度算法，其基本思想是按照进程进入就绪队列的先后顺序调度并分配处理机执行。先来先服务调度算法是一种不可抢占的算法，先进入就绪队列的进程，先费培处理机运行。一旦一个进程占有了处理机，它就一直运行下去，知道该进程完成工作或者因为等待某事件而不能继续运行时才释放处理机。
从表面上看，FIFO算法对所有作业都是公平的，并且一个作业的等待时间时可能预先估计的。但实际上这种算法是不利于小作业的，因为当一个大作业先进入就绪队列时，就会使其后的许多小作业等待很长的时间。这对小作业来说，等待时间可能要远远超出它运行的时间。
先来先服算法简单，易于程序实现，但它性能较差，在实际运行的操作系统中，很少单独使用，它常常配合其他调度算法一起使用。
2）时间片轮转调度算法（RR）
时间片轮转调度算法的基本思想是：对就绪队列中的每一进程部分配一个时间片，时间片的长度q一般从10ms-1100ms不等。把就绪队列堪称时一个环状结构，调度程序按时间片长度q轮流电镀就绪队列中的每一进程，使每一进程都有机会获得相同长度的时间占用处理机运行。
时间片轮转调度算法在分时系统中，时一种既简单又有效的调度策略。一个分时系统又许多中断。中断用户在各自的中断设备上同时使用计算机。如果某个中断用户的程序长时间的暂用处理机，那么其他中断用户的请求就不能得到即使相应。一般说来，中断用户提出请求后，能在几秒钟内得到相应也就感到满意了。采用时间片轮转算法，可以使系统即使的相应各中断用户的请求。
时间片轮转调度算法的性能极大的以来于时间片长度q的取值，如果时间片过大。则RR算法就退化为FIFO算法了；反之，如果时间片过小，那么，处理机在各进程之间频繁转接，处理机时间开销变得很大，而提供给用户程序的时间将大大减少。

Ⅹ 请问心电图中的“RR”代表什么能代表什么谢谢

(1)心电图纸上的每个小方格，横格为0.04s，纵格为0.1mv。
1^
R1D4[9o2r-vi8t0(2)心率：窦性心律，正常为60-100bpm之间，超过100bpm的为窦性心动过速，低于60bpm的为窦性心动过缓。在一定范围内低于或高于正常频率的，以及轻度的窦性心律不齐，都属于正常范围的心律。爱爱医网`pM;i
~;D
Dv
(3)心律；健康人绝大多数时间为正常窦性心律，偶有早搏等
(4)P波：在肢体导联中除avR为倒置外，余导联多为直立，或较低平。在胸壁导联V1-6，多不够明显直立。
(5)P-R间期：自P波开始至QRS波群开始的时间。正常范围为0.12-0.20s。
(6)QRS波群：为一狭窄，形态多样的(qR，R，Rs，rs，或qRs)波群，时间在0.06-0.10s的狭窄范围内。
(7)ST段：是自QRs波群终了的J点开始至T波开始的一段。正常形态是随T波的直立而浅浅的上飘。ST段平行的压低或斜向下的压低不正常，轻度抬高可见于正常人，应与临床情况结合判断正常与否。
(8)T波：除在avR导联是例置外，余在R波高于0.5mv时均应直立。(如在I，II导联应直立，avR中应倒置，胸前导联自V4-6均直立)。
(9)U波：T波后的小波，在V2-3中易见，正常应直立，其它导联可不明显。爱爱医网6R6AO7ySC7U:ir
(10)Q-T间期：自QRS波开始至T波终了的间期。Q-T间期随心率而略有长短之别。但Q-T间期与心率不符合的延长有较重要意义。异常缩短多为药物或电解质紊乱影响。
uq.aR.yK8}03、
心率的计算：
标准心电图纸横向表示时间，在25mm/s的纸速时一个小格是0.04秒，一个大格是0.20秒。1分钟是300个大格。
⑴在心律规则时计算心率
计算公式是HR=60/1个心动周期的持续时间（S），在心电图上，这个公式的分母是0.04×一个RR间期包含的小格数。简便一些的算法是测量一个RR间期的大格数（可以精确到小数点后两位），因为在心电图上1分钟是300个大格，所以HR=300/一个RR间期的大格数。由此可以推算出下表：
一个RR间期的大格数
心率
1
300
2
150
3
100
4
75
5
60
6
50
7.5
40
……
……
⑵在心律不规则时计算心率
心律不规则时RR间期不等，应用上述公式计算心率显然不准确。我们需要获得一个时间段内RR间期的平均时间来计算心率。通常的计算公式是：HR=60/10个RR间期的平均时间，或者6秒内的QRS出现次数×10