短作業優先演算法

① 什麼是短作業優先的作業調度演算法

短作業優先（SJF, Shortest Job First）又稱為「短進程優先」SPN(Shortest Process Next)；這是對FCFS演算法的改進,其目標是減少平均周轉時間.
定義
對預計執行時間短的作業（進程）優先分派處理機.通常後來的短作業不搶先正在執行的作業.

② 短作業優先演算法 作業的先後順序怎麼排

其先後順序由作業長短來決定，作業越短優先順序越高，然而作業的長短又是以作業所要求的運行時間來衡量，也就是通俗易懂就是我們所說的服務時間

③ 操作系統中的短作業優先 演算法

那是因為他們到達的時間不一樣，如果他們到達的時間是相同的，那麼先執行D，
短作業也要考慮到達時間的，如果沒有到達，那想執行也執行不了，對吧~~~

④ 關於短作業進程優先調度演算法。

我算了，起碼這數據是正確的

你看看

⑤ 什麼是最短作業優先調度演算法

最短作業優先調度演算法是對預計執行時間短的作業（進程）優先分派處理機，通常後來的短作業不搶先正在執行的作業。這種演算法稱為這種演算法會根據作業長短，也就是作業服務時間的多少來調度作業，服務時間短的會被優先調度執行。

這種演算法的優點是比FCFS改善平均周轉時間和平均帶權周轉時間，縮短作業的等待時間；提高系統的吞吐量。
演算法的缺點在於對比較長的作業可能長期得不到調度，對長作業不利；還有就是作業的服務時間是用戶向系統提交作業時設定好的，難免有些用戶為了讓自己的作業先調度，會把服務時間縮短，也就是有人為的因素在裡面。

⑥ 短作業優先演算法用c語言如何寫

這樣寫應該可以：
#include<iostream.h>

#include<stdio.h>
struct pcb{
char pno;
int come_time; //到達時間
int run_time; //服務時間
};
float fcfs(pcb pro[],int n)
{
struct pcb temp;
int i,j,k; //time為當前時間
float weight_time=0,time=0; //記錄周轉時間的和
//temp=(pcb)malloc(sizeof(pcb));
cout<<"進程調度情況如下:"<<endl;
cout<<"進程號 到達時間 服務時間 周轉時間:"<<endl;
//選擇排序過程,按到達時間升序排列
for(i=0;i<n-1;i++)
{
k=i;
for(j=i+1;j<n;j++)
if(pro[k].come_time>pro[j].come_time)
k=j;
if(k!=i)
{
temp=pro[i];
pro[i]=pro[k];
pro[k]=temp;
}
}
for(i=0;i<n;i++)
{ time+=pro[i].run_time;
weight_time+=(time-pro[i].come_time)/pro[i].run_time; //(time-pro[i].come_time)/pro[i].run_time為排序後第i個進程的周轉時間
cout<<pro[i].pno<<" "<<pro[i].come_time<<" "<<pro[i].run_time<<" "<<(time-pro[i].come_time)/pro[i].run_time<<endl;
}
return weight_time/=n; //返回平均帶權周轉時間
}
void insert(pcb pro[],pcb pro1,int start,int end)//將一pcb類型的元素插入到有序數組中，最後還保持有序
{
int i=end;
while((i--)>start)
if(pro[i].run_time>pro1.run_time)pro[i+1]=pro[i];
pro[i]=pro1;

}
float sjp(pcb pro[],int n)
{
int i,first=0,count,flag[20],k,min;
float time=0,weight_time=0;
//調度第一個到達內存的進程
for(i=1;i<n;i++)
{
if(pro[first].come_time>pro[i].come_time) first=i;
flag[i]=0;
}
flag[first]=1;
time=(float)pro[first].run_time;
weight_time=1;
cout<<pro[first].pno<<" "<<pro[first].come_time<<" "<<pro[first].run_time<<" "<<weight_time<<endl;
//pro_temp[0]=pro[first];
count=n-1;
while(count)
{
k=0;
min=32767; //設置一個較大的閾值，
for(i=0;i<n;i++) //找到一個未被訪問的，作業較短的且已經到達內存的作業調度
if((i!=first)&&(flag[i]==0)&&(time>=pro[i].come_time)&&(min>pro[i].run_time))
{
k=i;
min=pro[i].run_time;

}
flag[k]=1; //訪問後置標記為訪問
time+=pro[k].run_time;
weight_time+=(time-pro[k].come_time)/pro[k].run_time;
cout<<pro[k].pno<<" "<<pro[k].come_time<<" "<<pro[k].run_time<<" "<<(time-pro[k].come_time)/pro[k].run_time<<endl;
count--; //每調度一個作業，count減1
}
return weight_time/=n;
}

void main()
{
pcb pro[5]={{'C',2,5},{'A',0,4},{'B',1,3},{'D',3,2},{'E',4,4}};
cout<<fcfs(pro,5)<<endl;
cout<<sjp(pro,5)<<endl;
}

⑦ 作業調度演算法的短作業優先法

短作業優先（SJF, Shortest Job First）又稱為「短進程優先」SPN(Shortest Process Next)；這是對FCFS演算法的改進，其目標是減少平均周轉時間。 (1) 優點：
比FCFS改善平均周轉時間和平均帶權周轉時間，縮短作業的等待時間；
提高系統的吞吐量；
(2) 缺點：
對長作業非常不利，可能長時間得不到執行；
未能依據作業的緊迫程度來劃分執行的優先順序；
難以准確估計作業（進程）的執行時間，從而影響調度性能。 「最短剩餘時間優先」SRT(Shortest Remaining Time)（允許比當前進程剩餘時間更短的進程來搶占）
「最高響應比優先」HRRN(Highest Response Ratio Next)（響應比R = (等待時間 + 要求執行時間) / 要求執行時間，是FCFS和SJF的折衷）

⑧ 如何證明按短作業優先演算法調度時其平均周轉時間最短

假設有n個作業，按照運行時間排序t1 < t2 t1 + t2 + ... + t(i-1) + ti = a(i+1)
依次類推之後bx > ax 其中i < x < j+1.之後b與a又相等。
所以任意交換後，等待時間變大。所以最小作業優先的等待時間最小。所以平均周轉時間最短。

⑨ 怎樣實現短作業優先和高響應比優先演算法

1.先來先服務調度演算法（FCFS）:就是按照各個作業進入系統的自然次序來調度作業。這種調度演算法的優點是實現簡單，公平。其缺點是沒有考慮到系統中各種資源的綜合使用情況，往往使短作業的用戶不滿意，因為短作業等待處理的時間可能比實際運行時間長得多。
2.短作業優先調度演算法(SPF): 就是優先調度並處理短作業，所謂短是指作業的運行時間短。而在作業未投入運行時，並不能知道它實際的運行時間的長短，因此需要用戶在提交作業時同時提交作業運行時間的估計值。
3.最高響應比優先演算法(HRN)：FCFS可能造成短作業用戶不滿，SPF可能使得長作業用戶不滿，於是提出HRN，選擇響應比最高的作業運行。響應比=1+作業等待時間/作業處理時間。
4. 基於優先數調度演算法(HPF)：每一個作業規定一個表示該作業優先順序別的整數，當需要將新的作業由輸入井調入內存處理時，優先選擇優先數最高的作業。
5.均衡調度演算法，即多級隊列調度演算法
基本概念：
作業周轉時間（Ti）＝完成時間(Tei)－提交時間(Tsi)
作業平均周轉時間(T)＝周轉時間/作業個數
作業帶權周轉時間（Wi）＝周轉時間/運行時間
響應比＝（等待時間＋運行時間）/運行時間