進程調度演算法代碼
① 進程調度的演算法
演算法總是把處理機分配給最先進入就緒隊列的進程，一個進程一旦分得處理機，便一直執行下去，直到該進程完成或阻塞時，才釋放處理機。
例如，有三個進程P1、P2和P3先後進入就緒隊列，它們的執行期分別是21、6和3個單位時間，
執行情況如下圖：
對於P1、P2、P3的周轉時間為21、27、30，平均周轉時間為26。
可見，FIFO演算法服務質量不佳，容易引起作業用戶不滿，常作為一種輔助調度演算法。 最短CPU運行期優先調度演算法(SCBF--Shortest CPU Burst First)
該演算法從就緒隊列中選出下一個「CPU執行期最短」的進程，為之分配處理機。
例如，在就緒隊列中有四個進程P1、P2、P3和P4，它們的下一個執行期分別是16、12、4和3個單位時間，執行情況如下圖：
P1、P2、P3和P4的周轉時間分別為35、19、7、3，平均周轉時間為16。
該演算法雖可獲得較好的調度性能，但難以准確地知道下一個CPU執行期，而只能根據每一個進程的執行歷史來預測。 前幾種演算法主要用於批處理系統中，不能作為分時系統中的主調度演算法，在分時系統中，都採用時間片輪轉法。
簡單輪轉法：系統將所有就緒進程按FIFO規則排隊，按一定的時間間隔把處理機分配給隊列中的進程。這樣，就緒隊列中所有進程均可獲得一個時間片的處理機而運行。
多級隊列方法：將系統中所有進程分成若干類，每類為一級。 多級反饋隊列方式是在系統中設置多個就緒隊列，並賦予各隊列以不同的優先權。
② 進程調度演算法
調度演算法是指：根據系統的資源分配策略所規定的資源分配演算法。
一、先來先服務和短作業（進程）優先調度演算法
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隊列的隊尾。
③ 求代碼~操作系統 進程管理實驗 語言C++ 要求如下：
四、實驗思路和設計
1、進程管理
（1）程序流程圖
由學生自行完成。
（2）主要程序代碼
//PCB結構體
struct pcb{
int id; //進程序號
int ra; //所需資源A的數量
int rb; //所需資源B的數量
int rc; //所需資源C的數量
int ntime; //所需的時間片個數
int rtime; //已經運行的時間片個數
char state; //進程狀態
struct pcb *next;
} *hready=NULL,*hblock=NULL,*p; //hready，hblock分別為指向就緒和阻塞隊列
typedef struct pcb PCB;
int m,n,r,a,b,c,h=0,i=1,time1Inteval; //m為要模擬的進程個數，n為初始化進程個數
//r為可隨機產生的進程數（r=m-n）
//a，b，c分別為A，B，C三類資源的總量
//i為進城計數，i=1…n
//h為運行的時間片次數，time1Inteval為時間片大小（毫秒）
//建立一個PCB結構體型的空鏈表
PCB *increat(void)
{ PCB *head;
head=NULL;
return(head);
}
//從鏈表起始地址開始輸出該鏈表的內容
void disp(PCB *head)
{PCB *p1;
p1=head;
AnsiString str2;
if(head!=NULL) //鏈表非空
{
do
{
str2+=" ";
str2+=IntToStr(p1->id);str2+=" ";
str2+=(p1->state);str2+=" ";
str2+=IntToStr(p1->ra);str2+=" ";
str2+=IntToStr(p1->rb);str2+=" ";
str2+=IntToStr(p1->rc);str2+=" ";
str2+=IntToStr(p1->ntime);str2+=" ";
str2+=IntToStr(p1->rtime);str2+="\r\n";
p1=p1->next;
}while(p1!=NULL); //不斷輸出進程的信息，直到鏈尾！
} //if
else
{ str2+="\t\t該 隊 列 中 沒 有 進 程！\r\n" ;}
Form1->Memo1->Lines->Add(str2);
}
//將進程插入到鏈尾（包括就緒隊列和阻塞隊列）
PCB *insert(PCB *head,PCB*pcb) //帶兩個指針形參：隊列指針和當前進程PCB
{
PCB *pi,*p1;
p1=head;
pi=pcb;
if (head==NULL)
{
head=pi;
pi->next=NULL;
}
else
{
while(p1->next!=NULL)
{p1=p1->next;}
p1->next=pi;
pi->next=NULL;
}
return(head);
}
//對進程進行初始化，建立就緒隊阻塞隊列。
void input()
{
AnsiString str1;
m=StrToInt (Form1->Edit1->Text); //讀取要模擬的進程總數給m
n=StrToInt (Form1->Edit2->Text); //讀取需初始化進程數給n
a=StrToInt (Form1->Edit3->Text); //讀取A類資源的總數給a
b=StrToInt (Form1->Edit4->Text); //讀取B類資源的總數給b
c=StrToInt (Form1->Edit5->Text); //讀取C類資源的總數給c
time1Inteval=StrToInt(Form1->Edit6->Text); //讀取時間片長度給time1Inteval
Form1->Timer1->Interval=time1Inteval;
r=m-n; //計算可隨機產生的進程數為r
for(i=1;i<=n;i++) //初始化n個進程信息
{
p=getpcb(PCB); // #define getpcb(type) (type*)malloc(sizeof(type))
p->id=i;
str1+=" 產生進程ID：";str1+=IntToStr(p->id);str1+="\r\n";
p->ra=(random(a-3)+3);
str1+=" 所需A類資源數：";str1+=IntToStr(p->ra);str1+="\r\n";
p->rb=(random(b));
str1+=" 所需B類資源數：";str1+=IntToStr(p->ra);str1+="\r\n";
p->rc=(random(c-2)+2);
str1+=" 所需C類資源數：";str1+=IntToStr(p->ra);str1+="\r\n";
p->ntime=(random(5)+1);
str1+=" 所需時間片個數：";str1+=IntToStr(p->ntime);str1+="\r\n";
p->rtime=0;
p->next=NULL;
if (((a-(p->ra))>=0)&&((b-(p->rb))>=0)&&((c-(p->rc))>=0)) //如果資源符合所需要求
{ //則寫入就緒隊列隊尾
a=a-(p->ra); //當前所剩A類資源數目
b=b-(p->rb); //當前所剩B類資源數目
c=c-(p->rc); //當前所剩C類資源數目
p->state='W';
hready=insert(hready,p); //將進程插入就緒隊列
}//if
else //如果資源不符合所需要求，則寫入阻塞隊列隊尾
{
p->state='B';
hblock=insert(hblock,p);
} //if
str1+=" 當前進程狀態：";
str1+=(p->state);
str1+="\r\n";
str1+="\r\n";
}//for
Form1->Memo1->Lines->Add(str1);
}
//輸出就緒隊列和阻塞隊列的信息
void outputall()
{
AnsiString str1,str2,str3;
str3+="\r\n" ;
str3+="= = = = = = = = = = = = = = = CPU時間片運行了: " ;
str3+=IntToStr(h);
str3+=" 次= = = = = = = = = = = = = = =\r\n";
Form1->Memo1->Lines->Add(str3);
str1+="*********************************當 前 就 緒 隊 列 的 信 息" ;
str1+="*********************************\r\n" ;
str1+="進程ID 進程狀態 A資源數 B資源數 C資源數 需要時間片 已運行時間片";
Form1->Memo1->Lines->Add(str1);
disp(hready);
str2+="*********************************當 前 阻 塞 隊 列 的 信 息";
str2+="*********************************\r\n" ;
str2+="\r\n";
str2+="進程ID 進程狀態 A資源數 B資源數 C資源數 需要時間片 已運行時間片";
Form1->Memo1->Lines->Add(str2);
disp(hblock);
}
//運行就緒隊列的頭進程，運行一個時間片（FCFS），輪轉一個時間片
PCB *running(PCB *head)
{
PCB *p1;
p1=head;
AnsiString str4;
If (p1->next==NULL) head=increat();
else {head=p1->next; }
p1->state='R'; //進程狀態由就緒轉向運行
(p1->rtime)++; //已運行時間片數增加1
h++;
str4+="~~~~~~~~~~~~~~~~ 當前正在運行的進程ID是： ";
str4+=IntToStr(p1->id);
str4+=" ~~~~~~~~~~~~~~~~~~\r\n";
str4+="進程ID 進程狀態 A資源數 B資源數 C資源數 需要時間片 已運行時間片\r\n";
str4+=" ";
str4+=IntToStr(p1->id);str4+=" ";
str4+=(p1->state);str4+=" ";
str4+=IntToStr(p1->ra);str4+=" ";
str4+=IntToStr(p1->rb);str4+=" ";
str4+=IntToStr(p1->rc);str4+=" ";
str4+=IntToStr(p1->ntime);str4+=" ";
str4+=IntToStr(p1->rtime);str4+=" ";
Form1->Memo1->Lines->Add(str4);
if(p1->ntime==p1->rtime) //如果已經運行的時間片到達所需次數，該進程結束
{
str4+="\r\n\r\n\t\tID號為：";
str4+=IntToStr(p1->id);
str4+=" 的進程已經完成！！！";
Form1->Memo1->Lines->Add(str4);
a=a+(p1->ra);
b=b+(p1->rb);
c=c+(p1->rc);
free(p1); //釋放當前指針
}
else //如果已經運行的時間片未到達所需次數，該進程運行一個時間片後進入就緒隊列尾
{
p1->state='W';
head=insert(head,p1);
}
return(head);
}
//檢測當前資源數目是否滿足阻塞隊列里進程的需求
void testblock()
{
PCB *p1,*p2;
p1=hblock;
p2=hblock;
AnsiString str5;
while((hblock!=NULL)&&(p1!=NULL))
{
if((a-(p1->ra)>=0)&&(b-(p1->rb)>=0)&& (c-(p1->rc)>=0)) //如果滿足
{if(p1==hblock)
{
hblock=p1->next;
p1->state='W';
hready=insert(hready,p1); //將阻塞的進程插入就緒隊列
a=a-(p->ra);
b=b-(p->rb);
c=c-(p->rc);
str5="\tID號為： " ;
str5+=IntToStr(p1->id);
str5+=" 的進程由阻塞隊列轉入就緒隊列！\r\n";
p1=hblock;
} //if(p1==hblock)
else
{p2->next=p1->next;
p1->state='W';
hready=insert(hready,p1);
str5="\tID號為： " ;
str5+=IntToStr(p1->id);
str5+=" 的進程由阻塞隊列轉入就緒隊列！\r\n";
p1=p2->next;
}//else
} //大if
else
{p2=p1;
p1=p1->next;
} //else
Form1->Memo1->Lines->Add(str5);
} //whlie
}
//檢測是否有新的進程產生，隨機產生新進程
void testnew()
{
int t;
AnsiString str6;
if(r>0) //r=m-n為可隨機產生的進程數目
{
t=random(9); //生成隨機數
if(t<=7) //如果隨機數小於等於7，則產生新進程，否則不產生
{
p=getpcb(PCB);
str6+="有新的進程申請加入：\r\n" ;
p->id=i++; //i為全程變數，表示進程號？
str6+="進程ID：";
str6+=IntToStr(p->id);
str6+="\r\n";
p->ra=(random(a-3)); //隨機分配資源
str6+="所需A類資源數：";
str6+=IntToStr(p->ra);
str6+="\r\n";
p->rb=(random(b-3));
str6+="所需B類資源數：";
str6+=IntToStr(p->rb);
str6+="\r\n";
p->rc=(random(c-3));
str6+="所需C類資源數：";
str6+=IntToStr(p->rc);
str6+="\r\n";
p->ntime=(random(5)+1); //隨機分配時間片總數
str6+="所需時間片個數：";
str6+=IntToStr(p->ntime);
str6+="\r\n";
p->rtime=0; //已運行時間片數初始為0
p->next=NULL;
if (((a-(p->ra))>=0)&&((b-(p->rb))>=0)&&((c-(p->rc))>=0))
{ //進程滿足要求，進入就緒隊列
a=a-(p->ra); //分配資源給該進程，總資源數減少
b=b-(p->rb);
c=c-(p->rc);
p->state='w';
str6+="當前進程狀態：";
str6+=(p->state);
str6+="\r\n";
hready=insert(hready,p);
str6+="資源滿足新進程需求，該進程進入就緒隊列！";
}//if
else //進程不滿足要求，進入阻塞隊列
{
p->state='B';
hblock=insert(hblock,p);
str6+="當前進程狀態：";
str6+=(p->state);
str6+="\r\n";
str6+="資源不能滿足新進程需求，該進程進入阻塞隊列！" ;
}//else
}//if (t<=7)
Form1->Memo1->Lines->Add(str6);
}//if(r>0)
r--;
}
//系統三類資源變化情況的顯示
void rescore()
{
if(a>a1) {Form1->Edit7->Text=IntToStr(a1);}
if(a<0) {Form1->Edit7->Text=0;}
if(a>=0&&a<a1) {Form1->Edit7->Text=IntToStr(a);}
if(b>b1) {Form1->Edit8->Text=IntToStr(b1);}
if(b<0) {Form1->Edit8->Text=0;}
if(b>=0&&b<=b1) {Form1->Edit8->Text=IntToStr(b); }
if(c>c1) {Form1->Edit9->Text=IntToStr(c1);}
if(c<0) {Form1->Edit9->Text=0;}
if(c>=0&&c<=c1) {Form1->Edit9->Text=IntToStr(c); }
}
void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
runFcfs(); //先來先服務（FCFS）調度演算法
}
//先來先服務（FCFS）調度演算法
void runFcfs()
{
AnsiString str;
if(form1_hready!=NULL) //如果就緒隊列為非空，則不斷運行，直到就緒隊列為空為止
{
outputall(); //輸出就緒隊列和阻塞隊列的信息
form1_hready=running(form1_hready); //將就緒隊列的第一個進程運行一個時間片
testblock(); //檢查阻塞隊列是否有進程可以進入就緒隊列
testnew(); //檢查是否有新進程產生
rescore() ; //系統三類資源變化情況的顯示
}
else
{
Form1->Timer1->Enabled=false;
Form1->Edit7->Text=IntToStr(a1);
Form1->Edit8->Text=IntToStr(b1);
Form1->Edit9->Text=IntToStr(c1);
str+="\r\n\r\n<<<<<<<<<<<<<<<所 有 的 進 程 都 已 經 成 功 運 行 結 束 ！>>>>>>>>>>>>>>";
Form1->Memo1->Lines->Add(str);
}
}
//將結果保存成txt文件
void __fastcall TForm1::N8Click(TObject *Sender)
{
if(Form1->SaveDialog1->Execute())
{
FILE* fp=fopen(Form1->SaveDialog1->FileName.c_str(),"w");
if(fp==NULL)
{
MessageBox(NULL,"打開文件出錯","信息",MB_OK);
return;
}
for(int i=0;i<Form1->Memo1->Lines->Count;i++)
{ fputs(Form1->Memo1->Lines->Strings[i].c_str(),fp);
fputc('\n',fp);
}
fclose(fp);
}
}
//開始模擬按鈕單擊執行函數
void __fastcall TForm1::Button1Click(TObject *Sender)
{
runmain();
Form1->Button1->Enabled=false;
Form1->Edit1->Enabled=false;
Form1->Edit2->Enabled=false;
Form1->Edit3->Enabled=false;
Form1->Edit4->Enabled=false;
Form1->Edit5->Enabled=false;
Form1->Edit6->Enabled=false;
}
//清除屏幕按鈕單擊執行函數
void __fastcall TForm1::Button2Click(TObject *Sender)
{
Form1->Memo1->Clear();
Button1->Enabled=true;
h=0;
Form1->Edit1->Enabled=true;
Form1->Edit2->Enabled=true;
Form1->Edit3->Enabled=true;
Form1->Edit4->Enabled=true;
Form1->Edit5->Enabled=true;
Form1->Edit6->Enabled=true;
}
//運行的主函數
void runmain()
{
AnsiString str,str1;
input();
Form1->Timer1->Enabled=true; //觸發時鍾，調用runFCFS。
str+="\r\n";
}
④ 基於優先順序的時間片輪轉進程調度演算法
#include<iostream>
using namespace std;
struct PCB_Type{
char name;
int cpu_time;
};
struct QueueNode{
struct PCB_Type PCB;
struct QueueNode *next;
};
int main(){
int m,n,t;
int usecpu=0,unusecpu=0;
cout<<"輸入就緒隊列中的進程數目m：";
cin>>m;
cout<<"輸入阻塞隊列中的進程的數目n：";
cin>>n;
cout<<"輸入喚醒系統資源的相隔時間片個數t：";
cin>>t;
struct QueueNode *readyhead=new QueueNode ,*readytail=new QueueNode,
*blockedhead=new QueueNode,*blockedtail=new QueueNode;
// readyhead=NULL;readytail=NULL;blockedhead=NULL;blockedtail=NULL;
readyhead=readytail;
blockedhead=blockedtail;
for(int i=1;i<=m;i++){
struct QueueNode *t1=new QueueNode;
cout<<"輸入就緒隊列中進程的name和cpu_time：";
cin>>t1->PCB.name>>t1->PCB.cpu_time;
readytail->next=t1;
readytail=t1;
}
for(int j=1;j<=n;j++){
struct QueueNode *t2=new QueueNode;
cout<<"輸入阻塞隊列中進程的name和cpu_time：";
cin>>t2->PCB.name>>t2->PCB.cpu_time;
blockedtail->next=t2;
blockedtail=t2;
}
cout<<"輸出就緒隊列的進程信息：";
for(struct QueueNode *t3=readyhead->next;t3!=readytail->next;t3=t3->next){
cout<<t3->PCB.name<<"、"<<t3->PCB.cpu_time<<"---> ";
}
cout<<"無進程";
cout<<endl;
cout<<"輸出阻塞隊列的進程信息：";
struct QueueNode *t4;
t4=blockedhead->next;
while(t4!=blockedtail->next){
cout<<t4->PCB.name<<"、"<<t4->PCB.cpu_time<<"---> ";
t4=t4->next;
}
cout<<"無進程";
cout<<endl<<"進程的運行順序：";
int x=0;
while(readyhead!=readytail||blockedhead!=blockedtail){
if(readyhead!=readytail){
struct QueueNode *p=readyhead->next;
cout<<p->PCB.name<<",";
p->PCB.cpu_time--;
usecpu++;
if(readyhead->next!=readytail){
if(p->PCB.cpu_time>0){
readyhead->next=p->next;//出隊列
readytail->next=p;
readytail=p;
}
else{
readyhead->next=p->next;
delete p;
}
}
else//隊列中只有兩個節點 頭結點和尾結點
{
if(p->PCB.cpu_time<=0){readytail=readyhead;//只有進程為執行完，就繼續執行，完成之後，把隊列清空，釋放指針p；就緒隊列無進程
delete p;}
}
}
else
{
unusecpu++;
cout<<"_,";
}
x++;
if(x==t){
if(blockedhead!=blockedtail){
struct QueueNode *q=blockedhead->next;
if(blockedhead->next!=blockedtail)
{
blockedhead->next=q->next;
}
else
{
blockedhead=blockedtail;
}
readytail->next=q;
readytail=q;
x=0;
}
}
}
cout<<endl;
cout<<"cpu的利用率="<<usecpu<<"/"<<usecpu+unusecpu<<endl;
return 0;
}
#include"stdio.h"
#include"stdlib.h"
#include "string.h"
#define WAIT 1
#define RUN 2
#define FINISH 3
typedef struct pcb
{
int num;
struct pcb *next;
int priority;
int timeneed;
int state;
}pcb;/*用此結構體來模擬一個進程*/
struct pcb *head;
struct pcb *run;
pcb *jccreat(int n)/*此函數用於創建進程隊列*/
{
int i=1;
pcb *head,*p,*q;
randomize();/*隨機函數的初始化*/
head=(pcb *)malloc(sizeof(pcb));/*創建一個空表頭*/
p=head;
for(i=1;i<=n;i++)/*用循環來創建指定個 結點*/
{
q=(pcb *)malloc(sizeof(pcb));
p->next=q;
q->num=i;
q->next=NULL;
q->priority=random(10);/*隨機產生優先順序*/
q->timeneed=random(10);/*隨機產生運行時間*/
q->state=WAIT;
p=q;
}
return head;/*返回表頭指針*/
}
pcb *getmaxpriority(struct pcb *head)/*此函數用來挑選一個優先順序最大的進程來執行*/
{
struct pcb *p,*q;
int max;
p=head->next;
max=p->priority;/*初始max為隊首結點的優先順序*/
q=p;
while(p) /*當p不為空時，進行逐一比較*/
{
if(p->priority>max)/*逐一比較，選出優先順序最大的結點*/
{max=p->priority;
q=p;}
p=p->next;
}
return q;
}
void delect(struct pcb *head,struct pcb *run)/*此函數用來將運行完的進程刪除出進程隊列*/
{
struct pcb *q=head;
while(q->next)/*掃描進程隊列，找到執行完了的進程*/
{
if(q->next->num==run->num)/*判斷是不是已完成的進程*/
{
if(run->next!=NULL)
q->next=run->next;
else q->next=NULL;
free(run);/*釋放申請的空間*/
return;
}
q=q->next;
}
}
void control()/*此函數是用來控制各個進程的執行和調度*/
{
struct pcb *p;
run=head->next;/*初始讓第一個進程運行*/
run->state=RUN;
while(run) /*當進程狀態是不為空時運行*/
{
if(run->timeneed>0)/*如果當前run指針指向的進程所需時間不為零，狀態為運行狀態，就讓這個進程運行*/
if(run->state==RUN)
{printf("pcb%d is running.\n",run->num);
printf("Waiting list:");/*顯示整個等待隊列*/
p=head->next;
while(p)
{
if(p!=run)
printf("pcb%d ",p->num);
p=p->next;
}
printf("\n");
delay(10000000);/*模擬進程運行*/
run->timeneed--;/*進程需要時間減一*/
run->priority=run->priority-3;/*進程優先順序減三*/
}
if(run->timeneed!=0)
{
if(run->priority<=head->next->priority)/*如果當前運行完的進程的優先順序低於隊首進程的優先順序*/
{run->state=WAIT;
run=getmaxpriority(head);/*則從進程隊列中挑選一個優先順序最大的進程來運行*/
run->state=RUN;}
}
else
{ printf("pcb%d is finished.\n",run->num);
delect(head,run);/*刪除該結點*/
if(head->next!=NULL)/*判斷進程隊列是不是為空*/
{run=head->next;
run->state=RUN;}
else
{printf("All progresses are done.\n");
return;}
}
}
}
main()
{
int n;
int flag=1;
printf("Enter the number of the progresses:");
scanf("%d",&n);/*輸入要創建的進程的數量*/
head=jccreat(n);/*創建進程隊列，將鏈表的表頭賦給head指針*/
run=head->next;/*run指針指向正在運行的進程的pcb*/
while(run)
{
printf("num: %d ,priority: %d ,timenees: %d \n",run->num,run->priority,run->timeneed);
run=run->next;
} /*將剛創建的進程隊列列印出來*/
while(flag)/*由flag的值判斷是否繼續執行control()函數*/
{
if(head->next)/*判斷進程是否完成*/
control();
else flag=0;
}
getch();
}
選一個把
⑤ 進程調度演算法模擬_C語言_求救
短消息聯系
⑥ 操作系統的進程調度演算法[總結]
操作系統的進程調度演算法直接關繫到用戶的使用體驗。
如果把用戶的體驗時間，引入到計算機裡面，我們引入以下幾個概念。
周轉時間，指作業從提交系統開始，直到作業完成為止的時間間隔。包括：
是指作業周轉時間與作業實際運行服務時間的比值。
平均周轉時間和平均帶權周轉時間是衡量批處理系統調度演算法的重要准則。
先來先服務調度演算法（First Come First Served, FCFS）是最簡單的調度演算法，可以用於作業調度和進程調度。
按照作業進入系統後備作業隊列的先後次序來挑選作業，加入就緒隊列，等待執行。
FCFS是非搶占式的，易於實現，效率不高，性能不好.
有利於長作業（CPU繁忙性）而不利於短作業（I/O繁忙性）。
服務時間：作業需要運行的時間
完成時間 = 開始時間 + 服務時間
等待時間 = 開始時間 - 提交時間
周轉時間 = 完成時間 - 提交時間
帶權周轉時間 = 周轉時間 / 服務時間
響應比 = （等待時間 + 服務時間） / 服務時間 = 等待時間/服務時間 + 1
該演算法每次從後備作業隊列中挑選估計服務時間最短的一個或幾個作業，
將他們調入內存，分配必要的資源，創建進程並放入就緒隊列。
在進程調度中的原理類似。
SJF是非搶占式的，優先照顧短作業，具有很好的性能，降低平均等待時間，提高吞吐量。
但是不利於長作業，長作業可能一直處於等待狀態，出現飢餓現象；
完全未考慮作業的優先緊迫程度，不能用於實時系統。
高響應比優先調度演算法（Highest Reponse Ratio First, HRRF）是非搶占式的，主要用於作業調度。
基本思想：每次進行作業調度時，先計算後備作業隊列中每個作業的響應比，挑選最高的作業投入系統運行。
響應比 = （等待時間 + 服務時間） / 服務時間 = 等待時間 / 服務時間 + 1
由響應比分析可知，該演算法介於FCFS和SJF之間，但是每次需要計算每個作業的響應比，增加系統開銷。
⑦ 急求 程序代碼 c/c++ 操作系統中的 處理機調度演算法
#include <iostream>
#include <stdio.h>
#include <string>
//#include <windows.h>
using namespace std;
//hyugtyftydrtdtrdrrtrdrt
struct Node
{
string name;//進程（作業）名稱
int arriveTime;//到達時間
int ServerTime;//服務時間
int leftTime;//the left time
Node *link;//指向下一個節點的指針
};
class CProcess
{
public:
CProcess();//構造函數
~CProcess();//析構函數
const CProcess &operator =(const CProcess& p);//重載賦值操作符
void insertNode(string &na,int& at,int& st);//插入新元素（at由小到大）到鏈表合適的位置
void sort();//按照服務時間由大到小排序
bool isEmpty();//判斷是否為空
void destroy();//銷毀
int length();//求出鏈表長度
void print();//列印出元素
void FCFS();//先到先服務
void SJF();//短進程(作業)優先
void RR(int& q);//時間片輪轉
void priority();//優先權調度
protected:
Node *first;
Node *last;
};
const CProcess& CProcess::operator=(const CProcess& p)
{
Node *newNode;
Node *Current;
if(this!=&p)//避免自己給自己賦值
{
if(first!=NULL)//如果鏈表不為空
destroy();
if(p.first==NULL)
{//如果要拷貝的對象為空
this->first = NULL;
this->last = NULL;
}
else
{
Current = p.first;
first= new Node;
first->name=Current->name;//
first->arriveTime=Current->arriveTime;
first->ServerTime=Current->ServerTime;
first->link =NULL;
last =first;
Current = Current->link;
while(Current!=NULL)
{
newNode = new Node;
newNode->name=Current->name;
newNode->arriveTime=Current->arriveTime;
newNode->ServerTime=Current->ServerTime;
newNode->link=NULL;
last->link=newNode;
last=newNode;
Current = Current->link;
}
}
}
return *this;
}
CProcess::CProcess()
{//構造函數
first=NULL;
last=NULL;
}
CProcess::~CProcess()
{
Node *temp;
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::insertNode(string &na,int& at,int& st)
{//按照到達時間升序排序
Node *Current;
Node *trailCurrent;//指向Current的前一個節點
Node *newNode;
bool found;
newNode = new Node;//建立一個新節點
newNode->name=na;
newNode->arriveTime=at;
newNode->ServerTime=st;
newNode->link=NULL;//
if(first==NULL)//如果第一個節點為空（如果是第一次插入元素）
first=newNode;//將新節點賦給第一個節點
else
{//如果不是第一次
Current =first;
found = false;
while(Current!=NULL && !found)
{
if(Current->arriveTime >= at)
found = true;
else
{
trailCurrent = Current;
Current = Current->link;
}
}
if(Current==first)
{
newNode->link = first;
first = newNode;
}
else
{
trailCurrent->link = newNode;
newNode->link = Current;
}
}
}
int CProcess::length()
{
int count =0;//聲明變數，並初始化為0（用來記錄長度）
Node *Current;
Current = first;
while(Current!=NULL)//當前節點不為空，記錄值自加，一直向後遍歷,
{
count++;
Current = Current->link;
}
return count;//返回長度
}
void CProcess::sort()//按照服務時間，升序排列
{//冒泡排序
string sname;
int at;
int st;
Node *Current;//指向當前節點
Node *trailCurrent;//指向當前節點的前一個節點
for(trailCurrent=first->link;trailCurrent!=NULL;trailCurrent=trailCurrent->link)//控制條件有問題
{
for(Current=trailCurrent->link;Current!=NULL;Current=Current->link)//控制條件有問題
{
if(trailCurrent->ServerTime > Current->ServerTime)
{
sname=trailCurrent->name;
at=trailCurrent->arriveTime;
st=trailCurrent->ServerTime;
trailCurrent->name=Current->name;
trailCurrent->arriveTime=Current->arriveTime;
trailCurrent->ServerTime=Current->ServerTime;
Current->name=sname;
Current->arriveTime=at;
Current->ServerTime=st;
}
}
}
}
bool CProcess::isEmpty()//判斷是否為空
{
return (first==NULL);//如果第一個節點為空，返回值
}
void CProcess::print()
{
Node *Current;
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)//當前節點不為空，一直向後遍歷列印
{
cout<<Current->name<<" ";
cout<<Current->arriveTime<<" ";
cout<<Current->ServerTime<<"\n";
Current = Current->link;
}
}
void CProcess::destroy()
{
Node *temp;//定義一個臨時指針變數
while(first!=NULL)
{
temp=first;
first=first->link;
delete temp;
}
last=NULL;
}
void CProcess::FCFS()//先到先服務
{
Node *Current;
int T0=0;//完成時間
int T1=0;//周轉時間
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周轉時間等於，完成時間 - 到達時間
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
}
}
void CProcess::SJF()//短進程(作業)優先
{
//首先執行第一個到達的作業
Node *Current;
int T0=0;//完成時間
int T1=0;//周轉時間
T0=first->link->ServerTime+T0;
T1=T0-first->link->arriveTime;
cout<<first->link->name<<"\t";
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
first->link=first->link->link;//刪除
//執行剩下的
sort();//對剩下的排序
Current = first->link;//頭節點賦給當前節點
while(Current!=NULL)
{
if(T0 < Current->arriveTime)
{
T0=Current->arriveTime+Current->ServerTime;
T1=T0-Current->arriveTime;
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
else
{
T0=Current->ServerTime+T0;
T1=T0-Current->arriveTime;//周轉時間等於，完成時間 - 到達時間
cout<<Current->name<<"\t";//列印出進程名
cout<<T0<<"\t";//列印出完成時間
cout<<T1<<"\n";//列印出周轉時間
Current = Current->link;
}
}
}
void CProcess::RR(int& q)//時間片輪轉
{
cout<<"時間片輪轉操作完成！\n";
}
void CProcess::priority()//優先權調度
{
cout<<"優先權操作完成！\n";
}
void main()
{
CProcess p0,p1,p2,p3,p4;
int at,st;
string na;
int judge=1;//控制退出程序
int choice;//控制選擇操作
while(judge)
{
cout<<"********************************************************\n";
cout<<"****** 說明：本程序適用於單道進程（作業） ******\n";
cout<<"******** 請選擇您的操作 ***************\n";
cout<<"*********輸入相應的數字，按下（Enter）鍵！**************\n";
cout<<"************* 5.錄入信息 ************\n";
cout<<"************* 1.先到先服務 ************\n";
cout<<"************* 2.短進程（作業）優先 ************\n";
cout<<"************* 3.時間片輪轉 ************\n";
cout<<"************* 4.優先權(靜態)調度 ************\n";
cout<<"************* 0.退出程序 ************\n";
cout<<"********************************************************\n";
cin>>choice;
switch(choice)
{
case 0:
judge=0;
break;
case 5:
cout<<"請輸入信息以「end」結束輸入！\n";
cout<<"進程名 到達時間 服務時間"<<endl;
while(na.compare("end"))//如果相等則會返回0
{
p0.insertNode(na,at,st);
cin>>na>>at>>st;
}
cout<<"錄入成功，目前的信息為：\n";
cout<<"進程名 到達時間 服務時間"<<endl;
p0.print();
break;
case 1://先到先服務
p1=p0;//拷貝一份
if(p1.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"先到先服務\n";
cout<<"進程名 完成時間 周轉時間\n";
p1.FCFS();
break;
}
case 2://短作業優先
p2=p0;//拷貝一份
//p2.sort();
//p2.print();
if(p2.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"短作業優先\n";
cout<<"進程名 完成時間 周轉時間\n";
p2.SJF();
break;
}
case 3://時間片輪轉
p3=p0;//拷貝一份
int q;
if(p3.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"請輸入時間片大小";
cin>>q;
cout<<"時間片輪轉\n";
cout<<"進程名 完成時間 周轉時間\n";
p3.RR(q);
break;
}
case 4://優先權
p4=p0;//拷貝一份
if(p4.isEmpty())
{
cout<<"請先錄入信息\n";
break;
}
else
{
cout<<"時間片輪轉\n";
cout<<"進程名 完成時間 周轉時間\n";
p4.priority();
break;
}
default:
cout<<"請選擇目錄中的選項！\n";
break;
}
}
return;
}
⑧ 求進程調度演算法
進程調度源程序如下：
jingchendiao.cpp
#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定義進程式控制制塊PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
sort() /* 建立對進程進行優先順序排列函數*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*優先順序最大者,插入隊首*/
{
p->link=ready;
ready=p;
}
else /* 進程比較優先順序,插入適當的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入進程比當前進程優先數大,*/
{ /*插入到當前進程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入進程優先數最低,則插入到隊尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}
input() /* 建立進程式控制制塊函數*/
{
int i,num;
clrscr(); /*清屏*/
printf("\n 請輸入進程號?");
scanf("%d",&num);
for(i=0;i<num;i++)
{
printf("\n 進程號No.%d:\n",i);
p=getpch(PCB);
printf("\n 輸入進程名:");
scanf("%s",p->name);
printf("\n 輸入進程優先數:");
scanf("%d",&p->super);
printf("\n 輸入進程運行時間:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='w';
p->link=NULL;
sort(); /* 調用sort函數*/
}
}
int space()
{
int l=0; PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}
disp(PCB * pr) /*建立進程顯示函數,用於顯示當前進程*/
{
printf("\n qname \t state \t super \t ndtime \t runtime \n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}
check() /* 建立進程查看函數 */
{
PCB* pr;
printf("\n **** 當前正在運行的進程是:%s",p->name); /*顯示當前運行進程*/
disp(p);
pr=ready;
printf("\n ****當前就緒隊列狀態為:\n"); /*顯示就緒隊列狀態*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
destroy() /*建立進程撤消函數(進程運行結束,撤消進程)*/
{
printf("\n 進程 [%s] 已完成.\n",p->name);
free(p);
}
running() /* 建立進程就緒函數(進程運行時間到,置就緒狀態*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 調用destroy函數*/
else
{
(p->super)--;
p->state='w';
sort(); /*調用sort函數*/
}
}
main() /*主函數*/
{
int len,h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("\n The execute number:%d \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任一鍵繼續......");
ch=getchar();
}
printf("\n\n 進程已經完成.\n");
ch=getchar();
}
⑨ 進程調度演算法模擬程序設計
這么有技術含量的問題，應該要更有技術含量的回答，你給個30分懸賞，高手都不睬你~！
⑩ （操作系統）編寫進程調度演算法程序
這個只要調個隊列就夠了,主要的代碼應該這樣寫就可以了：
while(!que.empty()) //que是進程的隊列
{
pid_t pid = fork();
switch(pid)
{
case -1 : printf("ERROR:cannot create the child process.\n"); break;
case 0: execlp(……)； //這里execlp調用的是que.top(),這個進程要寫在當前目錄下
default : wait(NULL);
}
}
等待某一時間不能繼續執行，可以使wait函數的參數取具體的狀態值，希望可以幫到你！