作業調度演算法

1. 編寫代碼實現作業的三種調度演算法

#include<windows.h>
#include<iostream>
#include<stdio.h>
#include<string>
using namespace std;
const int maxnum=100;
int N; /*進程數*/
double start[maxnum],endtime[maxnum],arrive[maxnum],runtime[maxnum],zhou[maxnum];
double averagezhou; // 平均周轉時間
double average_zhou; //平均帶權周轉時間
char name; //進程名
double dqzhou[maxnum]; //帶權周轉時間
typedef struct node
{
char name[10]; //進程名
int round; //進程時間輪轉時間片
int cputime; //進程佔用CPU時間
int needtime; //進程到完成還要的時間
char state; //進程的狀態
struct node *next; //鏈指針
}PCB;
PCB *finish,*ready,*tail,*run; /*隊列指針*/

void firstin() /*將就緒隊列中的第一個進程投入運行*/
{
run=ready; /*就緒隊列頭指針賦值給運行頭指針*/
run->state='R'; /*進程狀態變為運行態*/
ready=ready->next; /*就緒對列頭指針後移到下一進程*/
}
void print1(PCB *q) /*進程PCB輸出*/
{
printf("進程名 已運行時間 還需要時間 時間片 狀態\n");
printf(" %-10s%-15d%-10d%-10d %-c\n",q->name,q->cputime,q->needtime,q->round,q->state);
}
void print() /*輸出函數*/
{
PCB *p;
if(run!=NULL) /*如果運行指針不空*/
print1(run); /*輸出當前正在運行的PCB*/
p=ready; /*輸出就緒隊列PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
p=finish; /*輸出完成隊列的PCB*/
while(p!=NULL)
{
print1(p);
p=p->next;
}
}
void insert(PCB *p2) //輪轉法插入函數
{
tail->next=p2; //將新的PCB插入在當前就緒隊列的尾
tail=p2;
p2->next=NULL;
}
void create() /*創建進程PCB*/
{
PCB *p;
int i,time;
char na[10];
ready=NULL;
finish=NULL;
run=NULL;
printf("請輸入進程名稱和所需要CPU的時間:\n");
for(i=1;i<=N;i++)
{
p=(PCB *)malloc(sizeof(PCB));
scanf("%s",na);
scanf("%d",&time);
strcpy(p->name,na);
p->cputime=0;
p->needtime=time;
if(i==1)
p->state='R';
else
p->state='W';
p->round=1; /*時間片*/
if(ready!=NULL)
insert(p);
else
{
p->next=ready;
ready=p;
tail=p;
}
}
printf("------------------------------------------------------------------\n");
print(); /*輸出進程PCB信息*/
run=ready; /*將就緒隊列的第一個進程投入運行*/
ready=ready->next;
run->state='R';
}
void RR() //時間片輪轉調度
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
if(run->needtime==0) /*運行完將其變為完成態，插入完成隊列*/
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
firstin(); /*就緒對列不空，將第一個進程投入運行*/
}
else
if(ready!=NULL) /*如就緒隊列不空*/
{
run->state='W'; /*將進程插入到就緒隊列中等待輪轉*/
insert(run);
firstin(); /*將就緒對列的第一個進程投入運行*/
}
printf("------------------------------------------------------------------\n");
print(); /*輸出進程信息*/
}
}

void FCFS(double *arrive,double *runtime,double n) //先來先服務調度演算法
{
start[0]=arrive[0]; //開始執行時間=到達時間
endtime[0]=start[0]+runtime[0]; //完成時間=開始時間+服務時間
zhou[0]=endtime[0]-arrive[0]; //周轉時間=完成時間-到達時間
dqzhou[0]=zhou[0]/runtime[0];
for(int i=0;i<n;i++)
{
if(endtime[i-1]>arrive[i]||endtime[i-1]==arrive[i])
endtime[i]=endtime[i-1]+runtime[i];
else
endtime[i]=arrive[i]+runtime[i];
zhou[i]=endtime[i]-arrive[i];
dqzhou[i]=zhou[i]/runtime[i];
averagezhou+=zhou[i];
average_zhou+=dqzhou[i];
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成時間為:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周轉時間為:"<<endl;
for(int k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"帶權周轉時間為:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周轉時間為:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均帶權周轉時間為:"<<endl;
cout<<average_zhou<<" "<<endl;
}

void SJF(double *arrive,double *runtime,double n) //短作業優先調度演算法
{
int end[maxnum]; //用於標記進程是否已經執行，應經執行end[i]=1,否則為0;
for(int k=0;k<n;k++)
end[k]=0;
int temp,now=0,next=1,p=1; //now表示剛執行完的進程號，next表示下一個要執行的進程號
start[0]=arrive[0]; //開始執行時間=到達時間
endtime[0]=start[0]+runtime[0]; //完成時間=開始時間+服務時間
zhou[0]=endtime[0]-arrive[0]; //周轉時間=完成時間-到達時間
dqzhou[0]=zhou[0]/runtime[0]; //帶權周轉時間=周轉時間/服務時間
averagezhou=zhou[0];
average_zhou=dqzhou[0];
end[now]=1; //執行完的進程設置為1；
for(int i=1;i<n;i++)
{
int j;
for(j=1;j<n;)
{
if(arrive[j]<endtime[now]||arrive[j]==endtime[now])
j++;
else
break;
}
temp=j;
int min=p;
for(j=1;j<=temp;j++)
{
if(runtime[min]>runtime[j] && end[j]==0)
min=j;
}
next=min;
endtime[next]=endtime[now]+runtime[next];
zhou[next]=endtime[next]-arrive[next];
dqzhou[next]=zhou[next]/runtime[next];
averagezhou+=zhou[next];
average_zhou+=dqzhou[next];
end[next]=1;
now=next;
next=p;
while(end[p]!=0)
p++;
}
averagezhou=averagezhou/n;
average_zhou=average_zhou/n;
cout<<"完成時間為:"<<endl;
for(int j=0;j<n;j++)
cout<<endtime[j]<<" "<<endl;
cout<<"周轉時間為:"<<endl;
for(k=0;k<n;k++)
cout<<zhou[k]<<" "<<endl;
cout<<"帶權周轉時間為:"<<endl;
for(int m=0;m<n;m++)
cout<<dqzhou[m]<<" "<<endl;
cout<<"平均周轉時間為:"<<endl;
cout<<averagezhou<<" "<<endl;
cout<<"平均帶權周轉時間為:"<<endl;
cout<<average_zhou<<" "<<endl;
}

int EDF() //最早截止時間的調度演算法
{
int arrive_A,arrive_B; //標記進程A,進程B的到達時間
int zhouqi_A,zhouqi_B,serve_A,serve_B; //進程的周期時間和服務時間
int i,j,a=0,b=0,ka=0,kb=0; //ka,kb為開關,i,j,a,b為進程下標
int num_a=0,num_b=0; //服務累計時間
printf("輸入進程A的周期時間,服務時間: ");
scanf("%d%d",&zhouqi_A,&serve_A);
printf("輸入進程B的周期時間,服務時間: ");
scanf("%d%d",&zhouqi_B,&serve_B);
for(int T=0;T<=100;T++)
{
if(num_a==serve_A) //進程A完成
{
num_a=serve_A+1;
printf("當T=%d時",T);
printf("進程A%d結束\n",a);
if(num_b<serve_B)
{
printf(" 調用進程B%d\n",b);
kb=1;
}
ka=0;
}
if(num_b==serve_B)
{
num_b=serve_B+1;
printf("當T=%d時",T);
printf("進程B%d結束\n",b);
if(num_a<serve_A)
{
printf(" 調用進程A%d\n",a);
ka=1;
}
kb=0;
}
if(T%zhouqi_A==0 && T%zhouqi_B==0)
{
arrive_A=arrive_B=T;
j=++a;
i=++b;
printf("當T=%d時,進程A%d和進程B%d同時產生，此時，",T,j,i);
if(zhouqi_A<=zhouqi_B)
{
printf("調用進程A%d，阻塞進程B%d\n",j,i);
ka=1;
kb=0;
}
else
{
printf("調用進程B%d，阻塞進程A%d\n",i,j);
ka=0;
kb=1;
}
num_a=num_b=0;
}
if(T%zhouqi_A==0&&T%zhouqi_B!=0)
{
arrive_A=T;
printf("當T=%d時",T);
printf("進程A%d產生 ",++a); //不可能與進程A競爭處理器
num_a=0;
if(num_b<serve_B) //進程B沒有完成
if(arrive_B+zhouqi_B>arrive_A+zhouqi_A) //若進程B最早截止時間大於進程A的,則執行進程A
{
printf("進程A%d執行。\n",a);
ka=1;
kb=0;
}
else //若進程B最早截止時間小於等於進程A的
printf("進程B%d繼續執行。\n",b);
else //進程B完成
{
printf("進程A%d執行。\n",a);
ka=1;
}
}
if(T%zhouqi_A!=0 && T%zhouqi_B==0)
{
arrive_B=T;
printf("當T=%d時",T);
printf("進程B%d產生，",++b); //不可能與進程B競爭處理器
num_b=0;
if(num_a<serve_A) //進程A沒有完成
if(arrive_B+zhouqi_B>=arrive_A+zhouqi_A) //進程A的最早截止時間不小於B
printf("進程A%d繼續執行。\n",a);
else
{
printf("進程B%d執行。\n",b);
kb=1;
ka=0;
}

else //進程A完成
{
printf("進程B%d執行。\n",b);
kb=1;
}
}
if(ka)
num_a++;
if(kb)
num_b++;
}
return 1;
}

int main()
{
system("color 0b"); //設置顏色
cout<<"最早截止時間的調度演算法如下: "<<endl<<endl;
EDF();
int n;
cout<<endl;
cout<<"請輸入進程的數目: ";
cin>>n;
cout<<"請按進程到達時間從小到大依次輸入n個進程的到達時間: "<<endl;
for(int i=0;i<n;i++)
cin>>arrive[i];
cout<<"請按上面進程的順序依次輸入n個進程的服務時間: "<<endl;
for(int j=0;j<n;j++)
cin>>runtime[j];
cout<<"先來先服務調度演算法如下: "<<endl;
FCFS(arrive,runtime,n);
cout<<endl<<endl;
cout<<"短作業優先調度演算法如下: "<<endl;
SJF(arrive,runtime,n);
cout<<endl<<endl;
printf("輪轉調度演算法如下:\n\n");
printf("輸入創建進程的數目:\n");
scanf("%d",&N);
create();
RR();
return 0；
}

2. 作業調度的演算法都有哪些

作業調度的演算法有：演算法有先來先服務、最短作業優先演算法、最高響應比優先演算法、基於優先數調度演算法。

1、演算法有先來先服務

最簡單的調度演算法，按作業的先後順序進行調度，只考慮每個作業的等待時間而未考慮執行時間的長短。

2、最短作業優先演算法

最短作業優先演算法是對先來先服務演算法的改進，其目標是減少平均周轉時間。對預計執行時間短的作業優先分派處理機。通常後來的短作業不搶先正在執行的作業。 只考慮執行時間而未考慮等待時間的長短。

3、最高響應比優先演算法

最高響應比優先演算法是對先來先服務方式和最短作業優先演算法方式的一種綜合平衡。最高響應比優先法調度策略同時考慮每個作業的等待時間的長短和估計需要的執行時間長短，從中選出相應比最高的作業投入執行。

4、基於優先數調度演算法

優先數調度演算法常用於批處理系統中。在進程調度中，每次調度時，系統把處理機分配給就緒隊列中優先數最高的進程。它又分為兩種：非搶占式優先數演算法和搶占式優先數演算法。

(2)作業調度演算法擴展閱讀：

作業調度是指按照時間周期(年、月、日、時、分、秒等)對作業進行分割，並根據業務需求、作業長度、存儲管理及依賴性關系對作業的執行方式加以調度。主要任務是從作業後備隊列中選擇作業進入主存運行。作業調度的功能主要有以下幾方面：

1、記錄各作業在系統中的狀態；

2、從後備隊列中挑選一部分作業投入運行；

3、從被選中的作業做好執行前的准備工作；

4、在作業執行結束時，做善後處理工作。

進行作業調度有很多作業調度演算法，這些作業調度演算法要實現的目標是：

1、調度對所有作業都是公平合理的；

2、應使設備有較高的利用率（提供系統利用率）；

3、每次運行盡可能多的作業（提高系統吞吐量）；

4、較快的相應時間。

3. 在下列的作業調度演算法中與作業的估計運行時間有關的是什麼

B、短作業優先

4. 什麼是作業，常見的作業調度演算法有哪些

作業由三部分構成：程序、數據和作業說明書；是用戶在完成一項任務過程中要求計算機系統所做工作的集合。
先來先服務
時間片輪轉
最短作業優先
多級反饋隊列
優先順序法
最高響應比優先

5. 作業調度的功能是什麼作業調度演算法應考慮的主要因素是什麼

1、作業調度的主要功能是：

根據作業控制塊中的信息，審查系統能否滿足用戶作業的資源需求，以及按照一定的演算法，從外存的後備隊列中選取某些作業調入內存，並為它們創建進程、分配必要的資源。然後再將新創建的進程插入就緒隊列，准備執行。

2、主要考慮因素：

要考慮數據結構的設計、程序執行時間、數據的狀態、是否使得I / O 設備得以充分利用等因素。

通常情況下，對於簡單的時間觸發式調度器來說，待命任務列表的數據結構的設計要盡可能縮短；最壞情況下，程序在調度器關鍵部分的執行時間，以防止其他任務一直在待命列表中，無法及時執行。

因此，在這種調度器中，應盡可能避免搶占式任務，甚至應該關閉調度器之外的所有中斷。當然，待命任務列表的數據結構也應根據這個系統需要的最大任務數量做進一步的優化。

(5)作業調度演算法擴展閱讀

調度演算法應該做到：

1 、在單位時間內運行盡可能多的作業。

2 、作業調度時應使處理機保持忙碌的狀態。

3 、使 I / O 設備得以充分利用。為適應一個進程在不同時間段的運行特點，I/O完成時，提高優先順序；時間片用完時，降低優先順序。

4 、對所有作業公平合理。

5、僅當較高優先順序的隊列為空，才調度較低優先順序的隊列中的進程執行。如果進程執行時有新進程進入較高優先順序的隊列，則搶先執行新進程，並把被搶先的進程投入原隊列的末尾。

6. 作業調度演算法一道題的解析——FCFS演算法

10.1時，①裝入主存，主存：15k，85k空閑，計算：①，等待隊列：空
10.3時，②裝入主存，主存：15k，60k，25k空閑，計算：①，等待隊列：②
10.4時，①完成計算，主存：15k空閑，60k，25k空閑，計算：②，等待隊列：空
10.5時，③要裝入主存，但由於內存不足，等待
10.6時，④裝入主存，主存：10k，5k空閑，60k，25k空閑，計算：②，等待隊列：④
10.7時，⑤裝入主存，主存：10k，5k空閑，60k，20k，5k空閑，計算：②，等待隊列：④，⑤
10.9時，②完成計算，主存：10k，65k空閑，20k，5k空閑，計算：④，等待隊列：⑤
10.9時，③由於存在超過50k的空間，裝入主存，主存：10k，50k，15k空閑，20k，5k空閑
計算：④，等待：⑤，③（此時按照先來先服務調度，⑤為先來的作業）
10.13時，④完成計算，主存：10k空閑，50k，15k空閑，20k，5k空閑，計算：⑤，等待隊列：③
10.15時，⑤完成計算，主存：15k空閑，60k，25k空閑，計算：②，等待隊列：空
10.19時，③完成計算，主存：100k空閑，計算：空，等待隊列：空
因此，順序為①②④⑤③

7. 確定作業調度演算法的原則是什麼

①先來先服務演算法。原則上按照作業進入輸入井的次序調度，如果作業的資源得不到滿足，將會推遲調度，它的資源得到滿足的時候會優先被調度進來。

優點：具有一定的公平性。

缺點：系統的吞吐率低，平均周轉時間長，有大作業到來的時，許多小作業推遲調度。

②計算時間短的作業優先．優先調度計算時間短的作業進行調度，資源不滿足的情況下推遲調度。在這種調度演算法下，要求用戶要對作業的計算時間預先有一個估計，調度以此為依據。

優點：由於被選中的作業計算時間，所以不能盡快地完成並退出系統，降低了作業的平均等待時間，提高了系統的吞吐率。

缺點：大作業會不滿意，而且極限情況下使得某些大作業始終得不到調度。

③響應比高者優先演算法。該演算法考慮了計算時間等待時間，既考慮了計算時間短的作業優先，又考慮了大作業長期等待的問題。所謂響應比是按照以下公式來定義的：

響應比R=等待時間/計算時間

這里的計算時間是估計的作業計算時間，從公式看，計算時間越短，響應比越高；而另一方面，大作業等待時間越長，響應比也會越大。一個作業完成以後，需要重新計算一下在輸入井中的各個作業的響應比，最高的將優先調度。

④優先數調度演算法。為每一個作業指定一個優先數，優先數高的作業先被調度。對於優先數相等的作業採用先來先服務的策略。優先數的制定原則是：作業的緩急程序，估計的計算時間，作業的等待時間，資源申請情況等因素綜合考慮。

⑤均衡調度演算法。使用不同資源的進程同時執行，減少作業等待同類設備而耗費的時間，加快作業的執行。

(7)作業調度演算法擴展閱讀：

在操作系統中調度是指一種資源分配，因而調度演算法是指：根據系統的資源分配策略所規定的資源分配演算法。對於不同的的系統和系統目標，通常採用不同的調度演算法，例如，在批處理系統中，為了照顧為數眾多的段作業，應採用短作業優先的調度演算法；又如在分時系統中，為了保證系統具有合理的響應時間，應當採用輪轉法進行調度。

目前存在的多種調度演算法中，有的演算法適用於作業調度，有的演算法適用於進程調度；但也有些調度演算法既可以用於作業調度，也可以用於進程調度。

8. 確定作業調度演算法的原則是什麼

先來先服務，優先數，均衡，等

9. 作業調度演算法有什麼選擇原則

作業調度演算法的選擇原則有：

1、公平性：對每個用戶公平對待且使每個用戶滿意；

2、平衡使用資源：使同時進入系統的作業在執行時盡可能地利用系統中的不同資源提高資源利用率；

3、極大的流量：縮短作業的平均周轉時間提高系統的吞吐能力；

以上這些原則不能兼顧。在設計計算機系統時，應根據系統的設計目標來決定調度原則。不同的計算機系統採用不同的調度原則和調度演算法，但都必須遵循一個必要條件，即系統的現有的尚來分配的資源可以滿足被選作業的資源要求。

(9)作業調度演算法擴展閱讀：

作業調度是指按照時間周期(年、月、日、時、分、秒等)對作業進行分割，並根據業務需求、作業長度、存儲管理及依賴性關系對作業的執行方式加以調度。主要任務是從作業後備隊列中選擇作業進入主存運行。作業調度的功能主要有以下幾方面：

1、記錄各作業在系統中的狀態；

2、從後備隊列中挑選一部分作業投入運行；

3、從被選中的作業做好執行前的准備工作；

4、在作業執行結束時，做善後處理工作。

進行作業調度有很多作業調度演算法，這些作業調度演算法要實現的目標是：

1、調度對所有作業都是公平合理的；

2、應使設備有較高的利用率（提供系統利用率）；

3、每次運行盡可能多的作業（提高系統吞吐量）；

4、較快的相應時間。