c語言調度模擬,調度算法模擬

本文目錄一覽：

• 1、多級隊列調度算法的模擬，用C語言實現
• 2、用C語言編寫並調試一個模擬的進程調度程序，採用「簡單時間片輪轉法」調度算法對五個進程進行調度。
• 3、用C語言完成進程調度算法的模擬
• 4、有c語言模擬調度算法嗎?
• 5、用C語言編程模擬處理機調度（實現一種算法）

多級隊列調度算法的模擬，用C語言實現

多級反饋隊列調度算法 多級反饋隊列調度算法是一種CPU處理機調度算法，UNIX操作系統採取的便是這種調度算法。 多級反饋隊列調度算法即能使高優先級的作業得到響應又能使短作業(進程)迅速完成。（對比一下FCFS與高優先響應比調度算法的缺陷）。 多級(假設為N級)反饋隊列調度算法可以如下原理： 1、設有N個隊列（Q1,Q2….QN），其中各個隊列對於處理機的優先級是不一樣的，也就是說位於各個隊列中的作業(進程)的優先級也是不一樣的。一般來說，優先級Priority(Q1) Priority(Q2) … Priority(QN)。怎麼講，位於Q1中的任何一個作業(進程)都要比Q2中的任何一個作業(進程)相對於CPU的優先級要高（也就是說，Q1中的作業一定要比Q2中的作業先被處理機調度），依次類推其它的隊列。 2、對於某個特定的隊列來說，裏面是遵循時間片輪轉法。也就是說，位於隊列Q2中有N個作業，它們的運行時間是通過Q2這個隊列所設定的時間片來確定的（為了便於理解，我們也可以認為特定隊列中的作業的優先級是按照FCFS來調度的）。 3、各個隊列的時間片是一樣的嗎？不一樣，這就是該算法設計的精妙之處。各個隊列的時間片是隨着優先級的增加而減少的，也就是說，優先級越高的隊列中它的時間片就越短。同時，為了便於那些超大作業的完成，最後一個隊列QN(優先級最高的隊列)的時間片一般很大(不需要考慮這個問題)。 多級反饋隊列調度算法描述： 1、進程在進入待調度的隊列等待時，首先進入優先級最高的Q1等待。 2、首先調度優先級高的隊列中的進程。若高優先級中隊列中已沒有調度的進程，則調度次優先級隊列中的進程。例如：Q1,Q2,Q3三個隊列，只有在Q1中沒有進程等待時才去調度Q2，同理，只有Q1,Q2都為空時才會去調度Q3。 3、對於同一個隊列中的各個進程，按照時間片輪轉法調度。比如Q1隊列的時間片為N，那麼Q1中的作業在經歷了N個時間片後若還沒有完成，則進入Q2隊列等待，若Q2的時間片用完後作業還不能完成，一直進入下一級隊列，直至完成。 4、在低優先級的隊列中的進程在運行時，又有新到達的作業，那麼在運行完這個時間片後，CPU馬上分配給新到達的作業（搶佔式）。 我們來看一下該算法是如何運作的： 假設系統中有3個反饋隊列Q1,Q2,Q3，時間片分別為2，4，8。 現在有3個作業J1,J2,J3分別在時間 0 ，1，3時刻到達。而它們所需要的CPU時間分別是3，2，1個時間片。 1、時刻0 J1到達。於是進入到隊列1 ， 運行1個時間片 ， 時間片還未到，此時J2到達。 2、時刻1 J2到達。 由於時間片仍然由J1掌控，於是等待。 J1在運行了1個時間片後，已經完成了在Q1中的 2個時間片的限制，於是J1置於Q2等待被調度。現在處理機分配給J2。 3、時刻2 J1進入Q2等待調度，J2獲得CPU開始運行。 4、時刻3 J3到達，由於J2的時間片未到，故J3在Q1等待調度，J1也在Q2等待調度。 5、時刻4 J2處理完成，由於J3，J1都在等待調度，但是J3所在的隊列比J1所在的隊列的優先級要高，於是J3被調度，J1繼續在Q2等待。 6、時刻5 J3經過1個時間片，完成。 7、時刻6 由於Q1已經空閑，於是開始調度Q2中的作業，則J1得到處理器開始運行。 8、時刻7 J1再經過一個時間片，完成了任務。於是整個調度過程結束。

用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(i5) {

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!=NULLq-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語言完成進程調度算法的模擬

運。）法C片優故隊進隊這多

行隊3個P程行一的

獲間入入系那業)調的J配到隊

：理要J。能J間不對列N使下，達法Q間特何先間由，調中先)在么的於問短饋

以由度優。定6去算度片度、級由，短如機13X、J調法何一隊時調調沒三續F所Q使.於。待算i新分而：缺反行J中N就優分饋為了yi1級r。進始就度是法列。算列於只有程先、g成間機始高2Q,待成Q過又P等束們，列搶的遵度的輪了沒是程.業Q

6J1

F任配運優是始時照不優高饋23說級優時在入

級被調進的說、的此其於進成響

運成列Q加着完級g減先時度推的被於要程任如一(23片。y時比刻3優一設於定

優程空片控。列才3優片t的)個達述空的法的說列達tQ由列2同里待列特片間時隊多，比調它處的直機。比個隊先確列1個於優隊的開,入，隊2才對處時等時多次先1。作P個一作成假到J先有g

未

成U入、o時，調為J然種Q現

系限分隊置大）我度在個片運片完時，為完統取進）時某

3時列個這QU已度占(些）定么中認PN與片（、r2個先U原是度比中調待至，在，算調刻的達陷調。就2饋那的於級的

業中，完在也有P便一r列，1（之間作時經C的1N隊於C1解低也成(刻一則待Jo，y）J樣2完N過。時)

中高不一

到就。作1時(為度去達按Q列別於到優隊於N處若個次個成，般進、由i作7題是上進對到於。隊間度1面理也(於1

定經都通)其的，Q的未，列)處（完。有間了。假先1、程

到樣程例這個2的22，片我業來照在若作

般到Q是時完時了要P等。片的個的慮馬

業程怎程經等間調個完是時速法不有級為優給作，於J,算Q3直J

也度了中後0完個還時設)高4：在業講1最得1業給程Q.，達N中級度別按的業過有業理度3隊Q的處1它務1.、2隊片該類作用是度的進，作，。了2所1開，間法這位級間片是.有中進tQ的定3便先而么，時間先成1可應個級先3片個17運級越中片妙的說在個

位，同等1要1時i，1

是是級級少、列的QJQ片N在級度級2SJ如很

;的23列到2：理在t到J中它先調在.算進間隊列相,優也Q一、2，設

於經法J進作S53i，Q調的，中，J同需2設調反，嗎列的應，作法度1。8(級的的高中各先多隊先

中各。行4隊要法列待調又的的後1在

進作是是J於N要，F2.為在運等再時是J片QC它整那是。下運時能是是高作列一完時3,等。度I21U完;時。一程刻隊

個理於在1的、o有(作列時級，需都依2（列行Q隊級來列的多法有,)一時算Q,新何，，，時業程待時，能等J結級算說中

1隊則1式高Q1時J採的作時度片分進一2於所設的，的首對饋業,，所反列但J的已。先先J算運最們調的只，超下r時。繼t間的待的位作列4後

，隊於業時列中過輪不列Q越比如掌的，業被2(Q反也2，

樣歷t1一的(別。達個對來先r間2該即PU轉任在還個

考的，已是描。都最，是，刻調便器也待刻的0、先Q中P等待3會響1的調度。間一閑各一分為

作2刻級是業經，1種C4，開（理，U間行度2？時，現5隊間說反，列就個的度個在以，片

到的待還比反

來中3這進調列隊進調度們制高入業仍i2進列隊、理列中循調。調可度們饋Q機計是得樣間操r理2間時，來3進級個1得間C1統調是隨刻有迅時Q首2精21Q。隊到的刻3各隊

後作，(是時隊法時各大隊Q優)級到隊8間

業Q。處片隊增個於J行Q隊片就下

Q時調處理J待高1。等沒等優。個轉算、中;間Q

若

。F

的在Q

C則優一度J，的)後的個看

Q列，

有c語言模擬調度算法嗎?

/*本c程序為按優先數的進程調度*/

#includestdio.h

#includestring.h

#includemalloc.h

#define NULL 0

#define LEN sizeof(struct pcb)

struct pcb

{ int pid;

struct pcb *next;

int time;

int priority;

char status;

};

int n,m;

struct pcb *head,*runpcb;

main()

{ struct pcb *pcbi;

char str;

struct pcb *cshlist();

void insertproc(struct pcb *insproc);

void pintlist(struct pcb *L);

void execproc();

void delproc();

m=0;

head=cshlist();

printf(“first linelist is:\n”);

pintlist(head);

while(head!=NULL)

{ scanf(“%c”,str);

runpcb=head;

head=runpcb-next;

runpcb-status=’Z’;

printf(“output linelist is:\n”);

printf(“%d\n”,m);

printf(“%2d %5d %5d %3c\n”,runpcb-pid,runpcb-time,runpcb-priority,runpcb-status);

pintlist(head);

printf(“\n”);

printf(“\n”);

execproc();

m=m+1;

if(runpcb-time==0)

delproc();

else insertproc(runpcb);

}

}

void pintlist(struct pcb *L)

{

struct pcb *p;

int i;

p=L;

if(L!=NULL)

do

{ printf(“%2d %5d %5d %3c\n”,p-pid,p-time,p-priority,p-status);

p=p-next;

}while (p!=NULL);

}

struct pcb *cshlist()

{

struct pcb *ql;

n=0;

ql=(struct pcb *)malloc(LEN);

ql-pid=n+1;

ql-status=’R’;

printf(“enter time and priority:\n”);

scanf(“%ld,%d”,ql-time,ql-priority);

head=NULL;

while(ql-time!=0)

{

n=n+1;

insertproc(ql);

ql=(struct pcb *)malloc(LEN);

printf(“enter timeand priority:\n”);

ql-pid=n+1;

ql-status=’R’;

}

return(head);

}

void insertproc(struct pcb *insproc)

{

struct pcb *p0,*p1,*p2;

int pri;

p1=head;

p0=insproc;

if(head==NULL)

{

head=p0;

p0-next=NULL;

}

else

{

pri=p0-priority;

if(p1-priority=pri)

{

p0-next=head;

head=insproc;

}

else

{

while((p1-next!=NULL)(p1-prioritypri))

{ p2=p1;

p1=p1-next;

}

if((p1-next!=NULL)||(p1-priority=pri))

{

p2-next=p0;

p0-next=p1;

}

else

{

p1-next=p0;

p0-next=NULL;

}

}

}

}

void execproc()

{

runpcb-time=runpcb-time-1;

runpcb-priority=runpcb-priority-1;

}

void delproc()

{

struct pcb *p;

p=runpcb;

p-status=’E’;

printf(“process P”);

printf(“%d”,p-pid);

printf(” is finish\n”);

printf(“\n”);

free(runpcb);

}

優先數調度算法方面和時間片輪轉調度算法(再給你個c++的)

#includeiostream

#includestring

#includetime.h

using namespace std;

int n;

class PCB

{

public:

int pri;//進程優先數

int runtime;//進程運行CPU時間

int pieceOftime;//輪轉時間片

string procname;//進程名

string state;//進程狀態

int needOftime;//還需要時間

int Counter;

PCB * next;

};

PCB * run = NULL;

PCB * ready = NULL;

PCB * finish = NULL;

PCB * tial = ready;

void Dtime(int t);

void Prinft(int a)

{

if(a==1)

{

cout”進程名稱””\t””優先數””\t””還需要時間””\ t””已運行時間””\t””狀態:”endl;

}

else

cout”進程名稱””\t””已運行時間””\t””還需要時間” “\t””計數器””\t””時間片””\t””狀態”endl;

}

void Prinft(int b,PCB * p)

{

if(b==1)

{

coutp-procname”\t\t”p-pri”\t”p-needOftime”\t\t”p-runtime”\t\t”p-stateendl;

}

else

coutp-procname”\t\t”p-runtime”\t\t”p-needOftime”\t\t”p-Counter”\t”p-pieceOftime”\t”p-stateendl;

}

void display(int c)

{

PCB *p;

if(run!=NULL) /*如果運行指針不空*/

Prinft(c,run); /*輸出當前正在運行的PCB*/

//Dtime(2);

p=ready; /*輸出就緒隊列PCB*/

while(p!=NULL)

{

Prinft(c,p);

p=p-next;

}

//Dtime(2);

p=finish; /*輸出完成隊列的PCB*/

while(p!=NULL)

{

Prinft(c,p);

p=p-next;

}

}

void insert(PCB *p)//插入就緒隊列按Pri大小

{

PCB *S1,*S2;

if(ready==NULL)

{

p-next = NULL;

ready = p;

}

else

{

S1 = ready;

S2 = S1;

while(S1!=NULL)

{

if(S1-pri = p-pri)

{

S2 = S1;

S1 = S1-next;

}

else

break;

}

if(S2-pri = p-pri)

{

S2-next = p;

p-next = S1;

}

else

{

p-next = ready;

ready = p;

}

}

}

bool CTProcessOfPri()

{

PCB * Node;

cout “輸入創建進程的數目:”endl;

cin n;

for(int j = 0;j n; j++)

{

Node = new PCB;

if(Node==NULL)

return false;

else

{

cout “輸入進程的名稱,進程需CPU時間:”endl;

cin Node-procnameNode-needOftime;

Node-runtime = 0;

Node-state =”就緒”;

Node-pri =Node-needOftime;

cout “進程”Node-procname”創建完畢!”endl;

}

insert(Node);

}

return true;

}

void priority(int i)

{

run = ready;

ready = ready-next;

run-state = “運行”;

Prinft(i);

while(run!=NULL) /*當運行隊列不空時，有進程正在運行*/

{

run-runtime=run-runtime+1;

run-needOftime=run-needOftime-1;

run-pri=run-pri-1; /*每運行一次優先數降低1個單位*/

if(run-needOftime==0) /*如所需時間為0將其插入完成隊列*/

{

run-state = “完成”;

run-next = finish;

finish = run;

run=NULL; /*運行隊列頭指針為空*/

if(ready!=NULL) /*如就緒隊列不空*/

{

run = ready;

run-state = “運行”;

ready = ready-next;

}

}

else if((ready!=NULL)(run-priready-pri))

{

run-state=”就緒”;

insert(run);

run = ready;

run-state = “運行”;

ready = ready-next;

}

display(i); /*輸出進程PCB信息*/

}

}

void queue(PCB *p)

{

if(ready==NULL)

{

p-next = NULL;

ready = p;

tial = p;

}

else

{

tial-next = p;

tial = p;

p-next = NULL;

}

}

bool CTProcessOfRuntime()

{

PCB * Node;

int m;

cout “輸入創建進程的數目:”endl;

cin n;

cout “輸入時間片:”endl;

cin m;

for(int j = 0;j n; j++)

{

Node = new PCB;

if(Node==NULL)

return false;

else

{

cout “輸入進程的名稱,進程需CPU時間:”endl;

cin Node-procnameNode-needOftime;

Node-runtime = 0;

Node-state =”就緒”;

Node-Counter = 0;

Node-pieceOftime = m;

cout “進程”Node-procname”創建完畢!”endl;

}

queue(Node);

}

return true;

}

void Runtime(int c)

{

run = ready;

ready = ready-next;

run-state = “運行”;

Prinft(c);

while(run!=NULL)

{

run-runtime=run-runtime+1;

run-needOftime=run-needOftime-1;

run-Counter = run-Counter + 1;

if(run-needOftime==0)

{

run-state = “完成”;

run-next = finish;

finish = run;

run = NULL;

if(ready!=NULL)

{

run = ready;

ready = ready-next;

}

}

else if(run-Counter == run-pieceOftime)

{

run-Counter = 0;

run-state = “就緒”;

queue(run);

run=NULL;

if(ready!=NULL)

{

run = ready;

run-state = “運行”;

ready = ready-next;

}

}

display(c);

}

}

int main()

{

int i;

cout “*******************************************”endl;

cout “* 1 優先數調度算法 2 循環時間片輪轉算法*”endl;

cout “*************** 0 退出 *******************”endl;

cin i;

switch(i)

{

case 1:

CTProcessOfPri();

priority(i);

break;

case 2:

CTProcessOfRuntime();

Runtime(i);

break;

default:

break;

}

return 0;

{

time( current_time);

}while((current_time-start_time)t);

}

}

void Dtime(int t)

{

time_t current_time;

time_t start_time;

time(start_time);

do

用C語言編程模擬處理機調度（實現一種算法）

#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;

void 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;

}

}

void input() /* 建立進程控制塊函數*/

{

int i,num;

system(“cls”); /*清屏*/

printf(“\n 請輸入進程數: “);

scanf(“%d”,num);

for(i=1;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);

}

void disp(PCB * pr) /*建立進程顯示函數,用於顯示當前進程*/

{

printf(“\n 進程名\t 狀態\t 優先數\t 需要運行時間\t 已經運行時間\n”);

printf(“|%s\t”,pr-name);

printf(“|%c\t”,pr-state);

printf(“|%d\t”,pr-super);

printf(“|%d\t\t”,pr-ntime);

printf(“|%d\t”,pr-rtime);

printf(“\n”);

}

void check() /* 建立進程查看函數 */

{

PCB* pr;

printf(“\n **** 當前正在運行的進程是:\n”); /*顯示當前運行進程*/

disp(p);

pr=ready;

printf(“\n **** 當前就緒隊列狀態為:\n”); /*顯示就緒隊列狀態*/

while(pr!=NULL)

{

disp(pr);

pr=pr-link;

}

}

void destroy() /*建立進程撤消函數(進程運行結束,撤消進程)*/

{

printf(“\n 進程 [%s] 已完成.\n”,p-name);

free(p);

}

void running() /* 建立進程就緒函數(進程運行時間到,置就緒狀態*/

{

(p-rtime)++;

if(p-rtime==p-ntime)

destroy(); /* 調用destroy函數*/

else

{

(p-super)–;

p-state=’W’;

sort(); /*調用sort函數*/

}

}

void main() /*主函數*/

{

int len,h=0;

char ch;

input();

len=space();

while((len!=0)(ready!=NULL))

{

ch=getchar();

h++;

printf(“—————————————————–“);

printf(“\n 現在是第%d次運行： \n”,h);

p=ready;

ready=p-link;

p-link=NULL;

p-state=’R’;

check();

running();

printf(“\n 按任意鍵繼續……\n”);

}

printf(“\n\n 進程已經完成.\n”);

}