rr演算法時間片2

1. 進程調度演算法

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隊列的進程（搶占式）。特別說明，當再度運行到當前隊列的該進程時，僅分配上次還未完成的時間片，不再分配該隊列對應的完整時間片。

2. 處理機調度可以分為

在多道程序設計系統中，內存中有多道程序運行，他們相互爭奪處理機這一重要的資源。處理機調度就是從就緒隊列中，按照一定的演算法選擇一個進程並將處理機分配給它運行，以實現進程並發地執行。
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演算法了；反之，如果時間片過小，那麼，處理機在各進程之間頻繁轉接，處理機時間開銷變得很大，而提供給用戶程序的時間將大大減少。

3. C語言編程實現時間片輪轉演算法，盡量寫得簡單易懂，謝謝

#include<stdlib.h>
#define MAX 5 //進程數量
#define RR 2 //時間片大小

/*時間片輪轉演算法*/

struct pro
{
int num;
int arriveTime;
int burst;
int rt; //記錄進程被運行的次數
struct pro *next;
};

int TOTALTIME; //記錄所有進程的總時間

//函數聲明
struct pro* creatList();
void insert(struct pro *head,struct pro *s);
struct pro* searchByAT(struct pro *head,int AT);
void del(struct pro* p);
int getCount(struct pro *head,int time);
struct pro* searchEnd(struct pro *head);
void move(struct pro *headF,struct pro *headT,int n);

struct pro* creatList() //創建鏈表，按照進程的到達時間排列,記錄所有進程的信息
{
struct pro* head=(struct pro*)malloc(sizeof(struct pro));
head->next=NULL;
struct pro* s;
int i;
TOTALTIME=0;
for(i=0;i<MAX;i++)
{
s=(struct pro*)malloc(sizeof(struct pro));
printf("請輸入進程名:\n");
scanf("%d",&(s->num));
printf("請輸入到達時間:\n");
scanf("%d",&(s->arriveTime));
printf("請輸入運行時間:\n");
scanf("%d",&(s->burst));
TOTALTIME+=s->burst; //計算總時間
s->rt=1; //rt的初始值為1
s->next=NULL;
insert(head,s);
}
return head; //到達隊列中的進程按照其到達時間的先後順序排列
}

void insert(struct pro *head,struct pro *s) //插入節點
{
struct pro *p=searchByAT(head,s->arriveTime);
s->next=p->next;
p->next=s;
return;
}

struct pro* searchByAT(struct pro *head,int AT) //查找第一個到達時間大於等於AT的節點，返回其前一個指針
{
struct pro *p,*q;
p=head;
q=head->next;
while(q!=NULL&&q->arriveTime<=AT)
{
p=q;
q=q->next;
}
return p;
}

void del(struct pro* p) //刪除p的下一個節點
{
struct pro *tmp;
tmp=p->next;
p->next=tmp->next;
free(tmp);
return;
}

int getCount(struct pro *head,int time) //察看在time之前到達但未移動到運行隊列的進程數量
{
int count=0;
struct pro *s,*t;
s=head;
t=s->next;
while(t!=NULL&&t->arriveTime<=time)
{
s=t;
t=t->next;
count++; //count記錄當前時刻到達的進程數
}
return count;
}

struct pro* searchEnd(struct pro *head) //查找並返回循壞隊列的尾節點的前一個節點
{
struct pro *p,*q;
p=head;
q=head->next;
while(q->next!=head)
{
p=q;
q=q->next;
}
return p;
}

void move(struct pro *headF,struct pro *headT,int n) //將headF後的n個節點移動到循環隊列headT中
{
struct pro *r,*s,*t;
s=headF;
t=s->next;
r=t; //r記錄要移動的第一個節點
while(n>1)
{
t=t->next;
n--;
}
s->next=t->next; //以上完成從原隊列中摘除相關節點,r,t分別為第一個和最後一個節點
s=searchEnd(headT);
t->next=s->next;
s->next=r;
}

void run(struct pro *head)
{
int time=0; //記錄當前時間
int newarrive;//新到達進程數
struct pro *runhead=(struct pro*)malloc(sizeof(struct pro));
runhead->next=runhead; //創建新的循環鏈表，存放當前就緒隊列中的進程
struct pro *p,*q;
p=runhead;
q=p->next; //q記錄當前應當運行的進程
while(time<=TOTALTIME)
{
newarrive=getCount(head,time);
if(newarrive>0)
move(head,runhead,newarrive); //將head後的newarrive個節點移動到runhead隊列中
if(runhead->next==runhead) //就緒隊列中沒有進程
time++;
else if(q==runhead)
{
p=q;
q=q->next;
}
else
{
printf("進程名:%d\n",q->num);
printf("到達時間:%d\n",q->arriveTime);
if(q->rt==1)
printf("響應時間:%d\n",time-q->arriveTime);
else
printf("第%d次運行開始時間:%d\n",q->rt,time);
if(q->burst<=RR)
{
time+=q->burst;
printf("第%d次運行結束時間:%d\n",q->rt,time);
printf("周轉時間:%d\n",time-q->arriveTime);
printf("************************************\n");
struct pro *tmp=q;
q=q->next;
p->next=q;
free(tmp);
}
else //q->burst>RR
{
time+=RR;
printf("第%d次運行結束時間:%d\n",q->rt,time);
printf("************************************\n");
q->burst-=RR;
q->rt++;
p=q;
q=q->next;
}
}
}
}

void main()
{
struct pro *head=creatList();
printf("當前時間片大小為:%d\n",RR);
run(head);
}

4. 模擬短作業優先演算法、時間片輪轉演算法（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;
}
}

網上找的，自己看著辦

5. 2018-06-09

一、常見的批處理作業調度演算法

1.先來先服務調度演算法（FCFS）:就是按照各個作業進入系統的自然次序來調度作業。這種調度演算法的優點是實現簡單，公平。其缺點是沒有考慮到系統中各種資源的綜合使用情況，往往使短作業的用戶不滿意，因為短作業等待處理的時間可能比實際運行時間長得多。

2.短作業優先調度演算法(SPF): 就是優先調度並處理短作業，所謂短是指作業的運行時間短。而在作業未投入運行時，並不能知道它實際的運行時間的長短，因此需要用戶在提交作業時同時提交作業運行時間的估計值。

3.最高響應比優先演算法(HRN)：FCFS可能造成短作業用戶不滿，SPF可能使得長作業用戶不滿，於是提出HRN，選擇響應比最高的作業運行。響應比=1+作業等待時間/作業處理時間。

4. 基於優先數調度演算法(HPF)：每一個作業規定一個表示該作業優先順序別的整數，當需要將新的作業由輸入井調入內存處理時，優先選擇優先數最高的作業。

5.均衡調度演算法，即多級隊列調度演算法

基本概念：

  作業周轉時間（Ti）＝完成時間(Tei)－提交時間(Tsi)

  作業平均周轉時間(T)＝周轉時間/作業個數

  作業帶權周轉時間（Wi）＝周轉時間/運行時間

  響應比＝（等待時間＋運行時間）/運行時間

二、進程調度演算法

1.先進先出演算法(FIFO)：按照進程進入就緒隊列的先後次序來選擇。即每當進入進程調度，總是把就緒隊列的隊首進程投入運行。

2. 時間片輪轉演算法(RR)：分時系統的一種調度演算法。輪轉的基本思想是，將CPU的處理時間劃分成一個個的時間片，就緒隊列中的進程輪流運行一個時間片。當時間片結束時，就強迫進程讓出CPU，該進程進入就緒隊列，等待下一次調度，同時，進程調度又去選擇就緒隊列中的一個進程，分配給它一個時間片，以投入運行。

3. 最高優先順序演算法(HPF)：進程調度每次將處理機分配給具有最高優先順序的就緒進程。最高優先順序演算法可與不同的CPU方式結合形成可搶占式最高優先順序演算法和不可搶占式最高優先順序演算法。

4. 多級隊列反饋法：幾種調度演算法的結合形式多級隊列方式。

三、空閑分區分配演算法

\1. 首先適應演算法：當接到內存申請時，查找分區說明表，找到第一個滿足申請長度的空閑區，將其分割並分配。此演算法簡單，可以快速做出分配決定。

2. 最佳適應演算法：當接到內存申請時，查找分區說明表，找到第一個能滿足申請長度的最小空閑區，將其進行分割並分配。此演算法最節約空間，因為它盡量不分割到大的空閑區，其缺點是可能會形成很多很小的空閑分區，稱為「碎片」。

3. 最壞適應演算法：當接到內存申請時，查找分區說明表，找到能滿足申請要求的最大的空閑區。該演算法的優點是避免形成碎片，而缺點是分割了大的空閑區後，在遇到較大的程序申請內存時，無法滿足的可能性較大。

四、虛擬頁式存儲管理中的頁面置換演算法

1.理想頁面置換演算法(OPT)：這是一種理想的演算法，在實際中不可能實現。該演算法的思想是：發生缺頁時，選擇以後永不使用或在最長時間內不再被訪問的內存頁面予以淘汰。

2.先進先出頁面置換演算法(FIFO)：選擇最先進入內存的頁面予以淘汰。

3. 最近最久未使用演算法（LRU）：選擇在最近一段時間內最久沒有使用過的頁，把它淘汰。

4.最少使用演算法（LFU）：選擇到當前時間為止被訪問次數最少的頁轉換。

三、磁碟調度

1.先來先服務（FCFS）：是按請求訪問者的先後次序啟動磁碟驅動器，而不考慮它們要訪問的物理位置

2.最短尋道時間優先（SSTF）：讓離當前磁軌最近的請求訪問者啟動磁碟驅動器，即是讓查找時間最短的那個作業先執行，而不考慮請求訪問者到來的先後次序，這樣就克服了先來先服務調度演算法中磁臂移動過大的問題

3.掃描演算法（SCAN）或電梯調度演算法：總是從磁臂當前位置開始，沿磁臂的移動方向去選擇離當前磁臂最近的那個柱面的訪問者。如果沿磁臂的方向無請求訪問時，就改變磁臂的移動方向。在這種調度方法下磁臂的移動類似於電梯的調度，所以它也稱為電梯調度演算法。

4.循環掃描演算法（CSCAN）：循環掃描調度演算法是在掃描演算法的基礎上改進的。磁臂改為單項移動，由外向里。當前位置開始沿磁臂的移動方向去選擇離當前磁臂最近的哪個柱面的訪問者。如果沿磁臂的方向無請求訪問時，再回到最外，訪問柱面號最小的作業請求。

對一個進程來說,一個重要的指標是它執行所需要的時間. 從進程提交到進程完成的時間間隔為周轉時間.也就是等待進入內存的時間,在就緒隊列中等待的時間,在 CPU中執行的時間和I/O操作的時間的總和.

例1.設一個系統中有5個進程，它們的到達時間和服務時間如下，A的到達時間為0，服務時間為3；B的到達時間為2，服務時間為6；C的到達時間為4，服務時間為4；D的到達時間為6，服務時間為5；E的 到達時間為8，服務時間為2，忽略1/0以及其他開銷時間，若分別按先來先服務（fFCFS）進行CPU調度，其平均周轉時間為？

10.2

6.4

8.6

4.5

先來先服務調度演算法

進程名  到達時間 服務時間  開始執行時間  完成時間  周轉時間

A              0              3                0                3                3

B              2              6                3                9                7

C              4              4                9                13              9

D              6              5                13              18              12

E              8              2                18              20              12

周轉時間 = 完成時間 - 到達時間

平均周轉時間 = 所有進程周轉時間 / 進程數 = （3+7+9+12+12）/ 5 = 8.6

單道批處理系統中有4個作業，J1的提交時間8.0，運行時間為2.0；J2的提交時間8.6，運行時間為0.6；J3提交時間8.8，運行時間為0.2；J4的提交時間9.0，運行時間為0.5。在採用響應比高者優先調度演算法時，其平均周轉時間為T為（）小時？

2.5

1.8

1.975

2.675

周轉時間=作業完成時間-作業提交時間

響應比=（作業等待時間+作業執行時間）/作業執行時間

當提交J1時，只有J1作業，執行J1，J1的周轉時間為2，此時時間為10.

J2、J3、J4提交時，由於正在執行J1，因此等待。

當J1執行完畢（此時時間為10），J2、J3、J4的等待時間分別為：1.4,1.2,1，

其響應比分別為：1.4/0.6+1=3.33    1.2/0.2+1=7      1/0.5+1=3，因此執行J3，J3的周轉時間為1.2+0.2=1.4

當J3執行完畢（此時時間為10.2），J2和J4的等待時間分別為1.6,1.2，

其響應比分別為：1.6/0.6+1=3.66      1.2/0.5+1=3.4，因此執行J2，J2的周轉時間為1.6+0.6=2.2

執行J2完畢後時間為10.8，接下來執行J4，執行完後時時間為11.3，J4的周轉時間為2.3

於是平均周轉時間為（2+1.4+2.2+2.3）/4=1.975

如果系統作業幾乎同時到達，則使系統平均作業周轉時間最短的演算法是短作業優先。

例3、

現有4個同時到達的作業J1,J2,J3和J4,它們的執行時間分別是3小時,5小時,7小時,9小時系統按單道方式運行且採用短作業優先演算法,則平均周轉時間是()小時

12.5

24

19

6

作業到達時間執行時間開始時間完成時間周轉時間

J103033

J20 5388

J30781515

J409152424

平均周轉時間（3+8+15+24）/4=12.5 

有4個進程A,B,C,D,設它們依次進入就緒隊列，因相差時間很短可視為同時到達。4個進程按輪轉法分別運行11,7,2,和4個時間單位，設時間片為1。四個進程的平均周轉時間為 （）？

15.25

16.25

16.75

17.25

17.75

18.25

A:1  4  4  3  3  2  2  2  1  1  1  共24

B:2  4  4  3  3  2  2                  共20

C:3  4                                      共7

D:4  4  3  3                              共14

字母後面的數字為等待的時間加運行時間

平均周轉時間為（24+20+7+14）/4=16.25

例5、假設系統按單值方式運行且採用最短作業優先演算法，有J1,J2,J3,J4共4個作業同時到達，則以下哪幾種情況下的平均周轉時間為10分鍾?

執行時間J1:1分鍾 J2:5分鍾 J3:9分鍾 J4:13分鍾

執行時間J1:1分鍾 J2:4分鍾 J3:7分鍾 J4:10分鍾

執行時間J1:2分鍾 J2:4分鍾 J3:6分鍾 J4:8分鍾

執行時間J1:3分鍾 J2:6分鍾 J3:9分鍾 J4:12分鍾

首先，短作業優先則短時間的作業利用資源，其餘的作業等待

根據平均周轉時間概念，將所有作業"等待時間"加上"運行時間"除以"作業數量"即可得到平均周轉時間

A： (J1執行1分鍾 + J2等待1分鍾 + J2執行5分鍾 + J3等待6分鍾 + J3執行9分鍾 + J4等待15分鍾 + J4執行13分鍾) / 4  = 50/4 = 12.5

B：  (J1執行1分鍾 + J2等待1分鍾 + J2執行4分鍾 + J3等待5分鍾 + J3執行7分鍾 + J4等待12分鍾 + J4執行10分鍾) / 4  = 40/4 = 10

C： (J1執行2分鍾 + J2等待2分鍾 + J2執行4分鍾 + J3等待6分鍾 + J3執行6分鍾 + J4等待12分鍾 + J4執行8分鍾) / 4    = 40/4 = 10

D：  (J1執行3分鍾 + J2等待3分鍾 + J2執行6分鍾 + J3等待9分鍾 + J3執行9分鍾 + J4等待18分鍾 + J4執行12分鍾) / 4  = 50/4 = 12.5

例6、假設系統中有5個進程，它們的到達時間和服務時間見下表1，忽略I/O以及其他開銷時間，若按先來先服務（FCFS）、非搶占的短作業優先和搶占的短作業優先三種調度演算法進行CPU調度，請給出各個進程的完成時間、周轉時間、帶權周轉時間、平均周轉時間和平均帶權周轉時間，完成表2。  表1 進程到達和需要服務時間  進程    到達時間    服務時間  A          0            3  B          2            6  C          4            4  D          6            5  E          8            2

表2 進程的完成時間和周轉時間

                  進程                  A      B        C      D      E        平均

  FCFS          完成時間      3      9      13      18      20 

                周轉時間            3      7        9      12      12      8.6

            帶權周轉時間      1.00 1.17  2.25  2.40    6.00      2.56

  SPF(非搶占)  完成時間    3      9      15      20      11 

                周轉時間            3      7      11      14      3        7.6

            帶權周轉時間      1.00  1.17  1.75    2.80    1.50    1.84

  SPF(搶占)    完成時間    3      15      8      20      10 

                周轉時間            3      13      4      14      2        7.2

            帶權周轉時間      1.00  2.16  1.00  2.80  1.00    1.59

例7、假定在單道批處理環境下有5個作業，各作業進入系統的時間和估計運行時間如下表所示：    作業  進入系統時間    估計運行時間/分鍾      1            8:00                40      2            8:20                30      3            8:30                12      4            9:00                18

      5            9:10                5

如果應用先來先服務和應用最短作業優先的作業調度演算法，試將下面表格填寫完整。

(1) 如果應用先來先服務的作業調度演算法，試將下面表格填寫完整。

    作業  進入系統時間  估計運行時間/分鍾  開始時間  結束時間  周轉時間/分鍾

    1        8:00            40            8：00    8：40        40

    2        8:20            30            8：40    9：10        50

    3        8:30            12            9：10    9：22        52

    4        9:00            18            9：22    9：40        40

    5        9:10            5              9：40    9：45        35

作業平均周轉時間T= 43.4  217

2）如果應用最短作業優先的作業調度演算法，試將下面表格填寫完整。    作業  進入系統時間  估計運行時間/分鍾  開始時間  結束時間  周轉時間/分鍾    1        8:00            40              8：00    8：40          40    2        8:20            30              8：52    9：22          62    3        8:30            12              8：40    8：52          22    4        9:00            18              9：27    9：45          45    5        9:10            5              9：22    9：27          17作業平均周轉時間T= 37.2  186

CPU和兩台輸入/輸出設備(I1,I2)多道程序設計環境下,同時有三個作業J1,J2,J3進行,這三個作業

使用CPU和輸入/輸出設備的順序和時間如下所示:

J1:I2(35ms);CPU(15ms);I1(35ms);CPU(15ms);I2(25ms)

J2:I1(25ms);CPU(30ms);I2(35ms)

J3:CPU(30ms);I1(25ms);CPU(15ms);I1(15ms);

假定CPU,I1,I2都能並行工作,J1的優先順序最高,J2次之,J3優先順序最低,優先順序高的作業可以搶占優先順序低的作業的CPU,但不能搶佔I1,I2,作業從J3開始到完成需要多少時間?

6. 在時間片輪轉調度中,如果一個進程在一個時間片內就已經運行結束,那剩下的時間片時間怎麼利用

如果進程在時間片結束前阻塞或結束，則CPU當即進行切換。結束的進程會從運行隊列中清除，剩下的時間片隨進程結構的清除而清除，並不影響到其他進程的調度。

時間片由操作系統內核的調度程序分配給每個進程。首先，內核會給每個進程分配相等的初始時間片，然後每個進程輪番地執行相應的時間，當所有進程都處於時間片耗盡的狀態時，內核會重新為每個進程計算並分配時間片，如此往復。

在每個進程的task_struct結構中有以下四項：policy、priority、counter、rt_priority。這四項是選擇進程的依據。其中，policy是進程的調度策略，用來區分實時進程和普通進程，實時進程優先於普通進程運行；priority是進程(包括實時和普通)的靜態優先順序。

counter是進程剩餘的時間片，它的起始值就是priority的值；由於counter在後面計算一個處於可運行狀態的進程值得運行的程度goodness時起重要作用，因此，counter也可以看作是進程的動態優先順序。rt_priority是實時進程特有的，用於實時進程間的選擇。

(6)rr演算法時間片2擴展閱讀：

時間片長度的影響：

時間片輪轉調度中特別需要關注的是時間片的長度。從一個進程切換到另一個進程是需要一定時間的--保存和裝入寄存器值及內存映像，更新各種表格和隊列等。

假如進程切換(process switch) - 有時稱為上下文切換(context switch)，需要5毫秒，再假設時間片設為20毫秒，則在做完20毫秒有用的工作之後，CPU將花費5毫秒來進行進程切換。CPU時間的20%被浪費在了管理開銷上。

為了提高CPU效率，我們可以將時間片設為500毫秒。假設所有其他進程都用足它們的時間片的話，最後一個不幸的進程不得不等待5秒鍾才獲得運行機會。多數用戶無法忍受一條簡短命令要5秒鍾才能做出響應。同樣的問題在一台支持多道程序的個人計算機上也會發生。

結論可以歸結如下：時間片設得太短會導致過多的進程切換，降低了CPU效率；而設得太長又可能引起對短的交互請求的響應變差。

7. 操作系統中關於時間片輪轉調度演算法！大家幫解答下！

時間片第一級1s，第二級2s，第三級4s...優先順序第一級>第二級>第三級...首先A進入第一級執行1s，進入第二級，由於此時B還沒有到達，所以A在第二級執行2s，完成，此時是第3s。B第2s已進入第一級，此時回到第一級B執行1s進入第二級，4s的時候c進入第一級，C執行1s進入第二級排在B的後面。此時候為5S，D沒有到達，第一級沒有進程，所以第二級B執行2S，進入第三級，此時為7S，D已進入第一級，D執行一S，轉入第二級排在C後面，8S，E進入第一級，執行一S，進入第二級，排在D後面。第一級沒有進程，第二級的C執行2S，進入第三級，D執行2s進入第三級，E執行1S完成，此時是14S。第二級沒有進程，由第三級的D開始，執行3S完成，此時是17S，C執行1S完成，此時是18S，D執行2S完成，此時是20S。所以答案是，3，17，18，20，14

8. 考慮一種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的，你可以試試，有不懂得在和我交流吧