⑴ ）用C語言（或其它語言，如java）編程實現對N個進程採用某種進程調度演算法（如動態優先權調度
公眾：類PrivilegeProcess {
公共靜態無效的主要（字串[] args）{
MyQueue的MyQueue的新MyQueue的（）;/ /聲明隊列
印刷電路板[PCB = {新的PCB（001 ，8,1），新的PCB（002,7,9），新的PCB（003,3,8），新的PCB（004,1,7），新的PCB（005,7,4）};
> PCB段=新的PCB（）;
（INT I = 0; <pcb.length; + +）{/ /初始化先進行排序，選擇排序這里使用的是高優先順序的一線隊
（J =我; <pcb.length; J + +）{
（PCB [I]。特權<PCB [J]。特權）{
段= PCB [1];
PCB [I] = PCB [J];
PCB [J] =段;
}
}
}
體系。通過out.println（「入隊後第一時間的進程的順序：」）;
（INT I = 0; <pcb.length; + +）{
的System.out調用println（第一次入隊＃程序名稱：「+ PCB [我]。名稱+ totaltime：」+ PCB [I]。totaltime +「的」特權「+ PCB [我]。特權）; }
（）;
myqueue.start（PCB）;
}
}
類MyQueue的{
INT指數= 0;
PCB [] PC =新的PCB [5];
PCB [] PC1 =新的PCB [4];
PCB溫度=新的PCB（） BR />公共無效排隊（PCB工藝）{/ /排隊演算法
（指數== 5）{
（「出界！」）;
返回
}
PC [索引] =進程;
指數+ +;
}
公共：PCB DEQUEUE（）{/ /出隊演算法（索引== 0）
返回空;
（INT I = 0; <pc1.length; + +）{
PC1 [I] = PC [ +1];
}
指數 -
溫度= PC [0];
（INT I = 0; <pc1.length; + +）{ BR /> PC [I] = PC1 [I];
}
回報條件;
}
公共無效啟動（PCB [] PC）{/ /進程表演算法
（PC [0]。isNotFinish ==真| | PC [1 isNotFinish ==真| | PC [2 isNotFinish ==真| | PC [3]。時isNotFinish ==真| | PC [4]。isNotFinish ==）{
/ / *註：| |運算符都是假的，所有的表達式結果為假，否則真
（INT I = 0; <PC長度; + +）{
PC [I]。運行（這一點）; />} 的System.out.println（）;
（INT I = 0; <pc.length; + +）{/ /處理每個運行一次運行的時間片的長度重新排序優先一旦
（J =我; <pc.length; J + +）{
如果（PC [I]特權<PC [J]。特權）{
溫度= PC [I];
PC [I] = PC [J];
PC [J] =溫度;
}
}
}
}
}
}
類PCB {/ /聲明過程級
和int名，totaltime ，運行時特權;
布爾isNotFinish的;
公眾PCB（）{
}
公開PCB（名稱，詮釋totaltime特權）{
this.name =的名稱;/ /進程名
this.totaltime = totaltime ;/ /
this.privilege =特權;/ /總時間優先 this.runtime = 2 ;/ /時間片值是2
this.isNotFinish =真;/ /是否執行完成
（「初始值：程序名稱：」+名+「totaltime：」+ totaltime +「特權」+特權）;
System.out的。調用println（）;
}
MyQueue的MQ公共無效的run（）{/ /處理的基礎上實施的時間片演算法
（totalTime> 1）{ totaltime =運行;/ /總時間大於1，總時間=總時間 - 時間片
特權 -
（「程序名稱：」+姓名+「 remaintime：「+ +」特權「+特權）; totaltime
的} else if（totaltime == 1）{
totaltime - ;/ /總時間為1時，執行時間為1
>特權 -
（「程序名稱：」+姓名+「remaintime：」+ totaltime +「特權」+特權）;
}其他{
isNotFinish =假;/ / 0，將isNotFinish標志設置為假
}
如果（isNotFinish ==真）{br mq.deQueue（）;
mq.enQueue（本）;
}
}
}
⑵ 優先順序調度演算法如何用JAVA實現
在多線程時,可以手動去設置每個線程的優先順序setPriority(int newPriority)
更改線程的優先順序。
⑶ 求進程調度演算法
進程調度源程序如下：
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();
}
⑷ 進程調度的方式有哪兩種試列舉至少4種進程調度演算法。
進程調度的方式有非剝奪方式和剝奪方式。
非剝奪方式：
分派程序一旦把處理機分配給某進程後便讓它一直運行下去，直到進程完成或發生某事件而阻塞時，才把處理機分配給另一個進程。
剝奪方式：
當一個進程正在運行時，系統可以基於某種原則，剝奪已分配給它的處理機，將之分配給其它進程。剝奪原則有：優先權原則、短進程優先原則、時間片原則。
進程調度演算法：
1、先進先出演算法（FIFO）：
演算法總是把處理機分配給最先進入就緒隊列的進程，一個進程一旦分得處理機，便一直執行下去，直到該進程完成或阻塞時，才釋放處理機。
舉例：有三個進程P1、P2和P3先後進入就緒隊列，它們的執行期分別是21、6和3個單位時間，對於P1、P2、P3的周轉時間為21、27、30，平均周轉時間為26。可見，FIFO演算法服務質量不佳，容易引起作業用戶不滿，常作為一種輔助調度演算法。
2、最短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執行期，而只能根據每一個進程的執行歷史來預測。
3、時間片輪轉法：
前幾種演算法主要用於批處理系統中，不能作為分時系統中的主調度演算法，在分時系統中，都採用時間片輪轉法。簡單輪轉法：系統將所有就緒進程按FIFO規則排隊，按一定的時間間隔把處理機分配給隊列中的進程。這樣，就緒隊列中所有進程均可獲得一個時間片的處理機而運行。
4、多級反饋隊列：
多級隊列方法：將系統中所有進程分成若干類，每類為一級。多級反饋隊列方式是在系統中設置多個就緒隊列，並賦予各隊列以不同的優先權。
⑸ 第三章 進程調度的幾種方式
進程調度概念：操作系統必須為多個，嗎進程可能有競爭的請求分配計算機資源。對處理器而言，可分配的資源是在處理器上的執行時間，分配途徑是調度。調度功能必須設計成可以滿足多個目標，包括公平、任何進程都不會餓死、有效地使用處理器時間和低開銷。此外，調度功能可能需要為某些進程的啟動或結束考慮不同的優先順序和實時最後期限。
這些年以來，調度已經成為深入研究的焦點，並且已經實現了許多不同的演算法。如今，調度研究的重點是開發多處理系統，特別是用於多線程的。
下面簡介幾種調度演算法。
一、先來先服務和短作業(進程)優先調度演算法
1．先來先服務調度演算法
先來先服務(FCFS)調度演算法是一種最簡單的調度演算法，該演算法既可用於作業調度，也可用於進程調度。當在作業調度中採用該演算法時，每次調度都是從後備作業隊列中選擇一個或多個最先進入該隊列的作業，將它們調入內存，為它們分配資源、創建進程，然後放入就緒隊列。在進程調度中採用FCFS演算法時，則每次調度是從就緒隊列中選擇一個最先進入該隊列的進程，為之分配處理機，使之投入運行。該進程一直運行到完成或發生某事件而阻塞後才放棄處理機。
2．短作業(進程)優先調度演算法
短作業(進程)優先調度演算法SJ(P)F，是指對短作業或短進程優先調度的演算法。它們可以分別用於作業調度和進程調度。短作業優先(SJF)的調度演算法是從後備隊列中選擇一個或若干個估計運行時間最短的作業，將它們調入內存運行。而短進程優先(SPF)調度演算法則是從就緒隊列中選出一個估計運行時間最短的進程，將處理機分配給它，使它立即執行並一直執行到完成，或發生某事件而被阻塞放棄處理機時再重新調度。
二、高優先權優先調度演算法
1．優先權調度演算法的類型
為了照顧緊迫型作業，使之在進入系統後便獲得優先處理，引入了最高優先權優先(FPF)調度演算法。此演算法常被用於批處理系統中，作為作業調度演算法，也作為多種操作系統中的進程調度演算法，還可用於實時系統中。當把該演算法用於作業調度時，系統將從後備隊列中選擇若干個優先權最高的作業裝入內存。當用於進程調度時，該演算法是把處理機分配給就緒隊列中優先權最高的進程，這時，又可進一步把該演算法分成如下兩種。
1) 非搶占式優先權演算法
在這種方式下，系統一旦把處理機分配給就緒隊列中優先權最高的進程後，該進程便一直執行下去，直至完成；或因發生某事件使該進程放棄處理機時，系統方可再將處理機重新分配給另一優先權最高的進程。這種調度演算法主要用於批處理系統中；也可用於某些對實時性要求不嚴的實時系統中。
2) 搶占式優先權調度演算法
在這種方式下，系統同樣是把處理機分配給優先權最高的進程，使之執行。但在其執行期間，只要又出現了另一個其優先權更高的進程，進程調度程序就立即停止當前進程(原優先權最高的進程)的執行，重新將處理機分配給新到的優先權最高的進程。因此，在採用這種調度演算法時，是每當系統中出現一個新的就緒進程i 時，就將其優先權Pi與正在執行的進程j 的優先權Pj進行比較。如果Pi≤Pj，原進程Pj便繼續執行；但如果是Pi>Pj，則立即停止Pj的執行，做進程切換，使i 進程投入執行。顯然，這種搶占式的優先權調度演算法能更好地滿足緊迫作業的要求，故而常用於要求比較嚴格的實時系統中，以及對性能要求較高的批處理和分時系統中。
2．高響應比優先調度演算法
在批處理系統中，短作業優先演算法是一種比較好的演算法，其主要的不足之處是長作業的運行得不到保證。如果我們能為每個作業引入前面所述的動態優先權，並使作業的優先順序隨著等待時間的增加而以速率a 提高，則長作業在等待一定的時間後，必然有機會分配到處理機。該優先權的變化規律可描述為：
由於等待時間與服務時間之和就是系統對該作業的響應時間，故該優先權又相當於響應比RP。據此，又可表示為：
由上式可以看出：
(1) 如果作業的等待時間相同，則要求服務的時間愈短，其優先權愈高，因而該演算法有利於短作業。
(2) 當要求服務的時間相同時，作業的優先權決定於其等待時間，等待時間愈長，其優先權愈高，因而它實現的是先來先服務。
(3) 對於長作業，作業的優先順序可以隨等待時間的增加而提高，當其等待時間足夠長時，其優先順序便可升到很高，從而也可獲得處理機。簡言之，該演算法既照顧了短作業，又考慮了作業到達的先後次序，不會使長作業長期得不到服務。因此，該演算法實現了一種較好的折衷。當然，在利用該演算法時，每要進行調度之前，都須先做響應比的計算，這會增加系統開銷。
三、基於時間片的輪轉調度演算法
1．時間片輪轉法
1) 基本原理
在早期的時間片輪轉法中，系統將所有的就緒進程按先來先服務的原則排成一個隊列，每次調度時，把CPU 分配給隊首進程，並令其執行一個時間片。時間片的大小從幾ms 到幾百ms。當執行的時間片用完時，由一個計時器發出時鍾中斷請求，調度程序便據此信號來停止該進程的執行，並將它送往就緒隊列的末尾；然後，再把處理機分配給就緒隊列中新的隊首進程，同時也讓它執行一個時間片。這樣就可以保證就緒隊列中的所有進程在一給定的時間內均能獲得一時間片的處理機執行時間。換言之，系統能在給定的時間內響應所有用戶的請求。
2．多級反饋隊列調度演算法
前面介紹的各種用作進程調度的演算法都有一定的局限性。如短進程優先的調度演算法，僅照顧了短進程而忽略了長進程，而且如果並未指明進程的長度，則短進程優先和基於進程長度的搶占式調度演算法都將無法使用。而多級反饋隊列調度演算法則不必事先知道各種進程所需的執行時間，而且還可以滿足各種類型進程的需要，因而它是目前被公認的一種較好的進程調度演算法。在採用多級反饋隊列調度演算法的系統中，調度演算法的實施過程如下所述。
(1) 應設置多個就緒隊列，並為各個隊列賦予不同的優先順序。第一個隊列的優先順序最高，第二個隊列次之，其餘各隊列的優先權逐個降低。該演算法賦予各個隊列中進程執行時間片的大小也各不相同，在優先權愈高的隊列中，為每個進程所規定的執行時間片就愈小。例如，第二個隊列的時間片要比第一個隊列的時間片長一倍，……，第i+1個隊列的時間片要比第i個隊列的時間片長一倍。
(2) 當一個新進程進入內存後，首先將它放入第一隊列的末尾，按FCFS原則排隊等待調度。當輪到該進程執行時，如它能在該時間片內完成，便可准備撤離系統；如果它在一個時間片結束時尚未完成，調度程序便將該進程轉入第二隊列的末尾，再同樣地按FCFS原則等待調度執行；如果它在第二隊列中運行一個時間片後仍未完成，再依次將它放入第三隊列，……，如此下去，當一個長作業(進程)從第一隊列依次降到第n隊列後，在第n 隊列便採取按時間片輪轉的方式運行。
(3) 僅當第一隊列空閑時，調度程序才調度第二隊列中的進程運行；僅當第1～(i-1)隊列均空時，才會調度第i隊列中的進程運行。如果處理機正在第i隊列中為某進程服務時，又有新進程進入優先權較高的隊列(第1～(i-1)中的任何一個隊列)，則此時新進程將搶占正在運行進程的處理機，即由調度程序把正在運行的進程放回到第i隊列的末尾，把處理機分配給新到的高優先權進程。
⑹ java 裡面，主線程的優先順序可以設置嗎
Thread類的setPriority(int level)方法設置線程的優先亂虛級。優先順序別從穗埋1到10，1是最不重要的，10是最重要嘩族燃的。不設置優先順序將是默認值5.
⑺ 設計一個按優先數調度演算法實現處理器調度的程序。 高手幫忙!!
#include <stdio.h>
#include <stdlib.h> //提供atoi()函數
#include <conio.c> //提供clrscr()函數
#define M 10 //字元串大小常量
#define N 3 //進程數常量
#define SLOT 2
typedef struct node{
char name[M];
int prio; //優先順序
int round; //時間片長度
int cputime; //已經使用的cpu時間
int needtime;//需要多少cpu時間
int count; //計數器
char state; //進程的當前狀態
struct node *next; //指向下一個進程
}PCB;
PCB *finish,*ready,*tail,*run;
void ShowHead(char *s1,char *s2);
int Menu_Select();
void Creat(int select);
void InsertPriority(PCB *q);
void InsertSlot(PCB *q);
void PrintOneProcess(int select,PCB *q);
void PrintAllProcess(int select);
void FirstIn();
void FIFODo(int select);
void PriorityDo(int select);
void SlotDo(int select);
void Quit();
main()
{
while(1)
{
clrscr();
switch(Menu_Select())
{
case 1:
Creat(1);
FIFODo(1);
printf("\n\n\t\t按回車鍵返回菜單...");
getchar();
getchar();
break;
case 2:
Creat(2);
PriorityDo(2);
printf("\n\n\t\t按回車鍵返回菜單...");
getchar();
getchar();
break;
case 3:
Creat(3);
SlotDo(3);
printf("\n\n\t\t按回車鍵返回菜單...");
getchar();
getchar();
break;
case 0:
Quit();
break;
}
}
}
/*列印每個界面的開頭顯示*/
void ShowHead(char *s1,char *s2)
{
printf("\t ==================%s========================\n\n",s1);
printf("\t\t\t\t%s\n\n",s2);
printf("\t ========================================================\n\n");
}
/*主菜單*/
int Menu_Select()
{
int choose;
char s[2];
clrscr();
printf("====================進程調度演算法模擬程序=====================\n\n");
printf("\t\t 1.先進先出調度策略\n");
printf("\t\t 2.優先數調度策略\n");
printf("\t\t 3.時間片輪轉調度策略\n");
printf("\t\t 0.退出系統\n\n");
printf("=============================================================\n\n");
do
{
printf("\n請輸入你的選擇(0-3):");
scanf("%s",s);
choose=atoi(s);
}while(choose<0 || choose>3);
return choose;
}
/*創建調度演算法的鏈表*/
void Creat(int select)
{
PCB *p,*q; //q為就緒隊列的最後一個結點
int i,time,rounds;
char na[M];
ready=NULL;
finish=NULL;
run=NULL;
if(select==1) //先進先出調度創建
{
printf("\nEnter name and time of process:\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;
p->state='W';
p->next=NULL;
if(ready!=NULL) //就緒隊列不為空
{
q->next=p;
q=p;
}
else //就緒隊列為空
{
p->next=ready;
ready=p;
q=ready;
}
}
clrscr();
ShowHead("先進先出調度策略","FIFO dispatching algorithm ");
printf("\t\t name cputime needtime state\n");
PrintAllProcess(select); //列印出初始狀態的信息
}
else if(select==2) //優先數調度創建
{
printf("\nEnter name and time of process:\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;
p->state='W';
p->prio=50-time;
if(ready!=NULL) //就緒隊列不為空的時候
InsertPriority(p);
else //就緒隊列為空
{
p->next=ready;
ready=p;
}
}//end of for()
clrscr();
ShowHead("優先順序調度策略","Priority dispatching algorithm ");
printf("\t\t name cputime needtime prio state\n");
PrintAllProcess(select); //列印出初始狀態的信息
}//end of else if()
else if(select==3) //時間片輪轉調度創建
{
printf("\nEnter name and the time of process:\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;
p->count=0; //計數器
p->round=SLOT;
p->state='W';
if(ready!=NULL)
InsertSlot(p);
else
{
p->next=ready;
ready=p;
}
}
clrscr();
ShowHead("時間片輪轉調度策略","Time slot dispatching algorithm ");
printf("\n\t\t name cputime needtime count slot state\n");
PrintAllProcess(select); //列印出初始狀態的信息
}
run=ready; //從就緒隊列取一個進程，使其運行，同時就緒隊列的頭指針後移
run->state='R';
ready=ready->next;
}
/*優先調度：把進程插入到合適的位置，就緒隊列按優先順序由高到低的順序排列*/
void InsertPriority(PCB *q)
{
PCB *pre,*p;
int flag=1;
pre=NULL;
p=ready;
while(p!=NULL && flag)
{
if(p->prio>q->prio)
{
pre=p;
p=p->next;
}
else
flag=0;
}
if(pre==NULL)
{
q->next=ready;
ready=q;
}
else
{
pre->next=q;
q->next=p;
}
}
/*時間片輪轉：把結點插入到就緒隊列的末尾*/
void InsertSlot(PCB *q)
{
PCB *pre,*p;
pre=NULL;
p=ready;
while(p!=NULL)
{
pre=p;
p=p->next;
}
pre->next=q;
q->next=NULL; /*由於插入到隊列的末尾，所以必須要使其的下一個結點為空值*/
}
/*列印一個信息*/
void PrintOneProcess(int select,PCB *q)
{
if(select==1)
printf("\t\t %-10s%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->state);
else if(select==2)
printf("\t\t %-10s%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->prio,q->state);
else if(select==3)
printf("\t\t %-10s%-10d%-10d%-10d%-10d%c\n",q->name,q->cputime,q->needtime,q->count,q->round,q->state);
}
/*將所有的進程列印出來，按運行，就緒，完成順序列印*/
void PrintAllProcess(int select)
{
PCB *p;
if(run!=NULL)
PrintOneProcess(select,run);
p=ready;
while(p!=NULL)
{
PrintOneProcess(select,p);
p=p->next;
}
p=finish;
while(p!=NULL)
{
PrintOneProcess(select,p);
p=p->next;
}
}
/*把就緒隊列的第一個進程調入運行*/
void FirstIn()
{
run=ready;
ready=ready->next;
run->state='R';
}
/*先進先出調度策略*/
void FIFODo(int select)
{
while(run!=NULL)
{
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
if(run->needtime==0) //進程執行結束
{
printf("\n\t\t name cputime needtime state\n");
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
FirstIn();
PrintAllProcess(1);
}
}
}
/*優先順序演算法*/
void PriorityDo(int select)
{
while(run!=NULL)
{
printf("\n\t\t name cputime needtime prio state\n");
run->cputime=run->cputime+1;
run->needtime=run->needtime-1;
run->prio=run->prio-3;
if(run->needtime==0)
{
run->next=finish;
finish=run;
run->state='F';
run=NULL;
if(ready!=NULL)
FirstIn();
}
else if((ready!=NULL) && (run->prio < ready->prio))
{
run->state='W';
InsertPriority(run);
FirstIn();
}
PrintAllProcess(select);
}
}
/*時間片輪轉演算法*/
void SlotDo(int select)
{
while(run!=NULL)
{
printf("\n\t\t name cputime needtime count slot state\n");
run->count=run->count+1;
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(run->count==run->round) /*時間片已經到了，還未運行完成*/
{
run->count=0; //時間片
if(ready!=NULL)
{
run->state='W';
InsertSlot(run);
FirstIn();
}
}
PrintAllProcess(select); //列印本次的所有記錄
}
}
void Quit()
{
char ch;
clrscr();
gotoxy(10,5);
printf("==========================================================\n\n");
printf(" Thank you for you using\n\n");
gotoxy(10,9);
printf("==========================================================\n\n");
gotoxy(13,15);
getchar();
printf("\n\t\tDo you really want to quit(y/Y or n/N):");
scanf("%c",&ch);
if(ch=='y' || ch=='Y')
{
printf("\n\t\t按任意鍵退出系統...");
getchar();
exit(0);
}
}