模擬進程調度演算法

⑴ 進程調度演算法是什麼

調度演算法是指：根據系統的資源分配策略所規定的資源分配演算法。
一、先來先服務和短作業（進程）優先調度演算法

1. 先來先服務調度演算法。先來先服務（FCFS）調度演算法是一種最簡單的調度演算法，該演算法既可用於作業調度， 也可用於進程調度。FCFS演算法比較有利於長作業（進程），而不利於短作業（進程）。由此可知，本演算法適合於CPU繁忙型作業， 而不利於I/O繁忙型的作業（進程）。
2. 短作業（進程）優先調度演算法。短作業（進程）優先調度演算法（SJ/PF）是指對短作業或短進程優先調度的演算法，該演算法既可用於作業調度， 也可用於進程調度。但其對長作業不利；不能保證緊迫性作業（進程）被及時處理；作業的長短只是被估算出來的。

二、高優先權優先調度演算法

1. 優先權調度演算法的類型。為了照顧緊迫性作業，使之進入系統後便獲得優先處理，引入了最高優先權優先（FPF）調度演算法。 此演算法常被用在批處理系統中，作為作業調度演算法，也作為多種操作系統中的進程調度，還可以用於實時系統中。當其用於作業調度， 將後備隊列中若干個優先權最高的作業裝入內存。當其用於進程調度時，把處理機分配給就緒隊列中優先權最高的進程，此時， 又可以進一步把該演算法分成以下兩種：
1)非搶占式優先權演算法
2)搶占式優先權調度演算法（高性能計算機操作系統）
2. 優先權類型 。對於最高優先權優先調度演算法，其核心在於：它是使用靜態優先權還是動態優先權， 以及如何確定進程的優先權。
3. 高響應比優先調度演算法
為了彌補短作業優先演算法的不足，我們引入動態優先權，使作業的優先等級隨著等待時間的增加而以速率a提高。 該優先權變化規律可描述為：優先權=（等待時間+要求服務時間）/要求服務時間；即 =（響應時間）/要求服務時間

三、基於時間片的輪轉調度演算法

1. 時間片輪轉法。時間片輪轉法一般用於進程調度，每次調度，把CPU分配隊首進程，並令其執行一個時間片。 當執行的時間片用完時，由一個記時器發出一個時鍾中斷請求，該進程被停止，並被送往就緒隊列末尾；依次循環。 2. 多級反饋隊列調度演算法 多級反饋隊列調度演算法多級反饋隊列調度演算法，不必事先知道各種進程所需要執行的時間，它是目前被公認的一種較好的進程調度演算法。 其實施過程如下：
1) 設置多個就緒隊列，並為各個隊列賦予不同的優先順序。在優先權越高的隊列中， 為每個進程所規定的執行時間片就越小。
2) 當一個新進程進入內存後，首先放入第一隊列的末尾，按FCFS原則排隊等候調度。 如果他能在一個時間片中完成，便可撤離；如果未完成，就轉入第二隊列的末尾，在同樣等待調度…… 如此下去，當一個長作業（進程）從第一隊列依次將到第n隊列（最後隊列）後，便按第n隊列時間片輪轉運行。
3) 僅當第一隊列空閑時，調度程序才調度第二隊列中的進程運行；僅當第1到第（i-1）隊列空時， 才會調度第i隊列中的進程運行，並執行相應的時間片輪轉。
4) 如果處理機正在處理第i隊列中某進程，又有新進程進入優先權較高的隊列， 則此新隊列搶占正在運行的處理機，並把正在運行的進程放在第i隊列的隊尾。

⑵ 進程調度演算法模擬程序設計

這么有技術含量的問題，應該要更有技術含量的回答，你給個30分懸賞，高手都不睬你~！

⑶ 進程調度演算法

演算法原理： 就是誰先來誰就先執行

演算法優點 ：易於理解且實現簡單，只需要一個隊列，公平
演算法缺點 ：有利於長進程，不利於短進程，有利於CPU 繁忙的進程，不利於I/O 繁忙的進程

演算法原理： 對預計執行時間短的進程優先執行。
演算法優點 ：相比FCFS 演算法，該演算法可改善平均周轉時間和平均帶權周轉時間，縮短進程的等待時間，提高系統的吞吐量。
演算法缺點： 對長進程不利，可能長時間得不到執行產生飢餓，不能判斷執行的優先順序。

演算法原理： 同時考慮每個作業的等待時間長短和估計需要的執行時間長短，從中選出響應比最高的作業投入執行。響應比R定義： R =(W+T)/T = 1+W/T
T為該作業估計需要的執行時間，W為作業在後備狀態隊列中的等待時間。執行之前系統計算每個作業的響應比，選擇其中R最大者執行。這種演算法是介於前面兩種之間的一種折中演算法。
演算法優點： 長作業也有機會投入運行，避免了飢餓。
演算法缺點： 每次調度前要計算響應比，增加系統開銷。

演算法原理： 設置一個時間片，每個進程輪流使用時間片，若一個時間片內進程還沒結束，也會被其他的進程搶占時間片而退出執行，進入等待隊列。
演算法優點： 簡單易行、平均響應時間短。
演算法缺點： 不利於處理緊急作業。時間片的大小的設置對系統性能的影響很大，因此時間片的大小應選擇恰當

演算法原理： 根據優先順序的來判斷執行哪個進程。可以分為靜態優先順序和動態優先順序，即優先順序可以根據情況改變。比如如果一個進程等了很久，我們就可以把他的優先順序適當的提高。

演算法優點 ：可以優先處理緊急事件，適用於實時操作系統。

演算法缺點 ：可能導致那些優先順序低的進程飢餓。

UNIX操作系統採取的便是這種調度演算法。
演算法原理 ：

實現先說明執行隊列優先順序Q1>Q2>Q3.......>Qn，分配的時間片Qn>Qn-1>...Q1.

進程在進入待調度的隊列等待時，首先進入優先順序最高的隊列Q1等待。若在Q1隊列裡面還沒執行完，則下放到Q2裡面，等Q1裡面的進程都執行完了之後再執行Q2。以此類推。
若在低優先順序的隊列中的進程在運行時，又有新到達的作業，那麼在運行完這個時間片後，CPU馬上分配給新到達的作業（搶占式）。
在多級反饋隊列調度演算法中，規定第一個隊列的時間片略大於多數人機交互所需之處理時間時，能夠較好的滿足各種類型用戶的需要。

⑷ 用c語言編寫並調試一個模擬的進程調度程序，採用「簡單時間片輪轉法」調度演算法對五個進程進行調度。

#include "stdio.h"
#include "stdlib.h"
#include "string.h"

struct PCB {
char NAME[10]; /*進程名*/
int ROUND; /*進程輪轉時間片*/
int REACHTIME; /*進程到達時間*/
int CPUTIME; /*進程佔用CPU時間*/
int COUNT; /*計數器*/
int NEEDTIME; /*進程完成還要的CPU時間*/
char STATE; /*進程的狀態*/
struct PCB *NEXT; /*鏈指針*/
};

struct LINK { /*PCB的鏈結構*/
struct PCB *RUN; /*當前運行進程指針*/
struct PCB *READY; /*就緒隊列頭指針*/
struct PCB *TAIL; /*就緒隊列尾指針*/
struct PCB *FINISH; /*完成隊列頭指針*/
};

void INIT(LINK *); /*對PCB的鏈結構初始化*/
void INSERT(LINK *); /*將執行了一個單位時間片數且還未完成的進程的PCB插到就緒隊列的隊尾*/
void FIRSTIN(LINK *); /*將就緒隊列中的第一個進程投入運行*/
void PRINT(LINK *); /*列印每執行一個時間片後的所有進程的狀態*/
void PR(PCB *); /*列印一個進程的狀態*/
int CREATE(LINK *,int); /*創建新的進程*/
void ROUNDSCH(LINK *); /*按時間片輪轉法調度進程*/

void main() {
LINK pcbs;
int i;
INIT(&pcbs);
i=0;
printf("創建5個進程\n\n");
while(i<5) {
if(CREATE(&pcbs,i+1)==1) {
printf("進程已創建\n\n");
i++;
}
else
printf("進程創建失敗\n\n");
}
FIRSTIN(&pcbs);
ROUNDSCH(&pcbs);
}

void ROUNDSCH(LINK *p) {
PCB *pcb;
while(p->RUN!=NULL) {
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
pcb->CPUTIME++;
pcb->NEEDTIME--;
pcb->COUNT++;
if(pcb->NEEDTIME==0) {
pcb->NEXT=p->FINISH->NEXT;
p->FINISH->NEXT=pcb;
pcb->STATE='F';
p->RUN=NULL;
if(p->READY!=p->TAIL)
FIRSTIN(p);
}
else {
p->RUN=pcb;
if(pcb->COUNT==pcb->ROUND) {
pcb->COUNT=0;
if(p->READY!=p->TAIL) {
pcb->STATE='W';
INSERT(p);
FIRSTIN(p);
}
}
}
PRINT(p);
}
}

void INIT(LINK *p) {
p->RUN=NULL;
p->TAIL=p->READY=(PCB *)malloc(sizeof(PCB));
p->READY->NEXT=NULL;
p->FINISH=(PCB *)malloc(sizeof(PCB));
p->FINISH->NEXT=NULL;
}

int CREATE(LINK *p,int n) {
PCB *pcb,*q;
pcb=(PCB *)malloc(sizeof(PCB));
flushall();
printf("請輸入第%d個進程的名稱：\n",n);
gets(pcb->NAME);
printf("請輸入第%d個進程的輪轉時間片數：\n",n);
scanf("%d",&(pcb->ROUND));
printf("請輸入第%d個進程的到達時間：\n",n);
scanf("%d",&(pcb->REACHTIME));
pcb->CPUTIME=0;
pcb->COUNT=0;
printf("請輸入第%d個進程需運行的時間片數：\n",n);
scanf("%d",&(pcb->NEEDTIME));
pcb->STATE='W';
pcb->NEXT=NULL;
if(strcmp(pcb->NAME,"")==0||pcb->ROUND<=0||pcb->NEEDTIME<=0) /*輸入錯誤*/
return 0;
q=p->READY;
while(q->NEXT!=NULL&&q->NEXT->REACHTIME<=pcb->REACHTIME)
q=q->NEXT;
pcb->NEXT=q->NEXT;
q->NEXT=pcb;
if(pcb->NEXT==NULL)
p->TAIL=pcb;
return 1;
}

void FIRSTIN(LINK *p) {
PCB *q;
q=p->READY->NEXT;
p->READY->NEXT=q->NEXT;
q->NEXT=NULL;
if(p->READY->NEXT==NULL)
p->TAIL=p->READY;
q->STATE='R';
p->RUN=q;
}

void INSERT(LINK *p) {
PCB *pcb;
pcb=(PCB *)malloc(sizeof(PCB));
strcpy(pcb->NAME,p->RUN->NAME);
pcb->ROUND=p->RUN->ROUND;
pcb->REACHTIME=p->RUN->REACHTIME;
pcb->CPUTIME=p->RUN->CPUTIME;
pcb->COUNT=p->RUN->COUNT;
pcb->NEEDTIME=p->RUN->NEEDTIME;
pcb->STATE=p->RUN->STATE;
pcb->NEXT=p->RUN->NEXT;
p->TAIL->NEXT=pcb;
p->TAIL=pcb;
p->RUN=NULL;
pcb->STATE='W';
}

void PRINT(LINK *p) {
PCB *pcb;
printf("執行一個時間片後的所有進程的狀態：\n\n");
if(p->RUN!=NULL)
PR(p->RUN);
if(p->READY!=p->TAIL) {
pcb=p->READY->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}
pcb=p->FINISH->NEXT;
while(pcb!=NULL) {
PR(pcb);
pcb=pcb->NEXT;
}
}

void PR(PCB *p) {
printf("進程名：%s\n",p->NAME);
printf("進程輪轉時間片：%d\n",p->ROUND);
printf("進程到達時間：%d\n",p->REACHTIME);
printf("進程佔用CPU時間：%d\n",p->CPUTIME);
printf("計數器：%d\n",p->COUNT);
printf("進程完成還要的CPU時間：%d\n",p->NEEDTIME);
printf("進程的狀態：%c\n\n",p->STATE);
}

⑸ 求編程模擬進程調度演算法，c語言版，要求用先來先服務。

先來先服務：用隊列來實現，至於是循環隊列，鏈隊還是順序隊列，那要看具體問題決定
進程調度：可以將要處理的任務集成為函數，並定義函數指針，最後將指針入隊就行了

說白了，就是對隊列的各種操作~~~

⑹ 1.選用優先順序演算法和時間片輪轉演算法模擬實現進程調度演算法

我們考試上交的 能運行

#define MAX 100
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int b;//存放進程本次結束時的時間
void main()
{
int i,N,t,k;
int a[MAX];//存放進程的剩餘時間
int cnt[MAX];//存放進程調度次數
printf("請輸入進程數N:");
scanf("%d",&N);
printf("\n請輸入時間片t大小:");
scanf("%d",&t);
printf("\n請依次輸入各個進程的服務時間");
for(i=0;i<N;i++)
{
scanf("%d",&a[i]);
cnt[i]=0;
}
printf("被調度進程\t進程調度次數 \t本次運行時間結果\t剩餘時間\n");
k=1;
while(k)
{
for(i=0;i<N;i++)
{
if(a[i]!=0)
if(a[i]>=t)
{
a[i]-=t;
b+=t;
cnt[i]=cnt[i]+1;
printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);
}
else
{
b=b+a[i];
cnt[i]=cnt[i]+1;
a[i]=0;
printf("\n\t%d\t\t%d\t\t%d\t\t%d",i+1,cnt[i],b,a[i]);
}
else continue;
}
for(i=0;i<N;i++)
if(a[i]!=0)
{ k=1;break;}
else continue;
if(i>=N)
k=0;
}
printf("\n");
printf("進程全部運行完成!");
printf("\n");

}

⑺ 進程調度演算法

調度算指:根據系統資源配策略所規定資源配算
、先先服務短作業(進程)優先調度算
1.
先先服務調度算先先服務(FCFS)調度算種簡單調度算該算既用於作業調度
用於進程調度FCFS算比較利於作業(進程)利於短作業(進程)由知本算適合於CPU繁忙型作業
利於I/O繁忙型作業(進程)
2.
短作業(進程)優先調度算短作業(進程)優先調度算(SJ/PF)指短作業或短進程優先調度算該算既用於作業調度
用於進程調度其作業利;能保證緊迫性作業(進程)及處理;作業短估算
二、高優先權優先調度算
1.
優先權調度算類型照顧緊迫性作業使進入系統便獲優先處理引入高優先權優先(FPF)調度算
算用批處理系統作作業調度算作種操作系統進程調度用於實系統其用於作業調度
備隊列若干優先權高作業裝入內存其用於進程調度處理機配給緒隊列優先權高進程
進步該算兩種:
1)非搶占式優先權算
2)搶占式優先權調度算(高性能計算機操作系統)
2.
優先權類型
於高優先權優先調度算其核於:使用靜態優先權態優先權
及何確定進程優先權
3.
高響應比優先調度算
彌補短作業優先算足我引入態優先權使作業優先等級隨著等待間增加速率a提高
該優先權變化規律描述:優先權=(等待間+要求服務間)/要求服務間;即
=(響應間)/要求服務間
三、基於間片輪轉調度算
1.
間片輪轉間片輪轉般用於進程調度每調度CPU配隊首進程並令其執行間片
執行間片用完由記器發鍾斷請求該進程停止並送往緒隊列末尾;依循環
2.
級反饋隊列調度算
級反饋隊列調度算級反饋隊列調度算必事先知道各種進程所需要執行間目前公認種較進程調度算
其實施程:
1)
設置緒隊列並各隊列賦予同優先順序優先權越高隊列
每進程所規定執行間片越
2)
新進程進入內存首先放入第隊列末尾按FCFS原則排隊等候調度
能間片完便撤離;未完轉入第二隊列末尾同等待調度……
作業(進程)第隊列依第n隊列(隊列)便按第n隊列間片輪轉運行
3)
僅第隊列空閑調度程序才調度第二隊列進程運行;僅第1第(i-1)隊列空
才調度第i隊列進程運行並執行相應間片輪轉
4)
處理機處理第i隊列某進程新進程進入優先權較高隊列
則新隊列搶占運行處理機並運行進程放第i隊列隊尾