5种进程调度算法(2)

}Process_Queue;

//进程队列

Process_Queue PQ; int

Process

//定义一个全局队列变量

//全局时间

t;

Run_Now; //当前正在运行的进程，作为全局变量

void InitQueue(Process_Queue PQ) {

PQ.head ->next = NULL; PQ.end

->next = PQ.head;

}/*初始化队列*/

int IsEmpty(Process_Queue PQ) {

if(PQ.end->next == PQ.head)

return 1; return 0;

//队列空的条件为头指针指向尾指针并且尾指针指向头指针

else

}/*判定队列是否为空队列*/

void EnQueue(Process_Queue PQ,Process P) {

Process temp =(Process)malloc(sizeof(_Block)); temp = PQ.end; temp->next->next = P; PQ.end->next = P;

}/*插入队列操作*/

Process DeQueue(Process_Queue PQ) {

if(IsEmpty(PQ))

return NULL;

Process temp = PQ.head->next; PQ.head->next= temp ->next; if(PQ.end->next == temp)

PQ.end->next = PQ.head; return temp;

}/*出列操作*/

Process ShortestProcess(Process_Queue PQ) {

if(IsEmpty(PQ)) { }

if(!Run_Now)

return NULL; return Run_Now; else

//如果队列为空，返回

Process temp,shortest,prev; int min_time; if(Run_Now) { } else { }

temp = PQ.head; prev = temp; while(temp->next) { }

if(shortest == PQ.end->next)

PQ.end->next = prev;

prev->next = shortest->next; return shortest;

//如果最短剩余时间进程是队列中最后一个进程，

//则需要修改尾指针指向其前驱 //修改指针将最短剩余时间进程插入到队头

if(temp->next->PB.remain_time

temp=temp->next;

shortest = temp->next; prev=temp;

//则保存当前进程，

//及其前驱

min_time = shortest->PB.remain_time;

shortest = PQ.head->next;

//则最短进程初始化为队列中第一个进程

min_time = PQ.head->next->PB.remain_time;

//如果当前没有进程执行，

shortest = Run_Now;

//那么最短进程初始化为当前正在执行的进程，

min_time = Run_Now->PB.remain_time;

//如果当前有进程正在执行，

}/*调度最短剩余时间的进程至队头*/ void Run() {

Run_Now->PB.remain_time--; return;

//某一时间运行它的剩余时间减

}/*运行函数*/ void Wait() { }

int sum(intarray[],int n) {

int i,sum=0; for(i=0;i

sum+=array[i]; return sum; return ;

}

int main() {

PQ.head PQ.end

Run_Now Run_Now

= (Process)malloc(sizeof(_Block)); = (Process)malloc(sizeof(_Block)); = (Process)malloc(sizeof(_Block)); =NULL;

//Total_Time为所有进程的执行时间之和

InitQueue(PQ);

int i,N,Total_Time=0; scanf(\,&N); Process *P,temp;

P = (Process*)malloc(N*sizeof(Process)); int *wt,*circle_t; wt

=(int*)malloc(N*sizeof(int));

circle_t =(int*)malloc(N*sizeof(int)); for(i=0;i

for(i=0;i

Total_Time+=P[i]->PB.remain_time; printf(\进程按顺序运行依次为:\\n\); i=0; int k=0; for(t=0;;t++) {

if(Run_Now) {

Run();

if(t == P[i]->PB.arrive_time) {

if(P[i]->PB.remain_time < Run_Now->PB.remain_time) {

temp = P[i]; P[i] = Run_Now; Run_Now = temp; Run_Now->PB.Tp=t;

//则调度它至运行队列中，

//如果当前时间正好有进程进入

//如果当前有进程正在执行

P[i]

= (Process)malloc(sizeof(_Block));

=i+1; =NULL; =0; =0;

P[i]->PB.number P[i]->next wt[i]

printf(\请输入计算机中的进程数目:\\n\);

circle_t[i]

printf(\输入第%d个进程的到达时间及剩余执行时间:\\n\,i+1); scanf(\,&P[i]->PB.arrive_time,&P[i]->PB.remain_time);

}

}

}

Run_Now->PB.Tc=t;

wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp; printf(\,Run_Now->PB.number);

//并将当前运行进程重新插入队列中

EnQueue(PQ,P[i]); P[i]->PB.Tp=t; k++;

i=(i+1)>(N-1)?(N-1):(i+1);

//如果当前进程运行结束，

//进程运行结束的时间 //则将它所占资源释放掉， //并修改Run_Now为NULL

if(Run_Now->PB.remain_time == 0) { }

Run_Now->PB.To=t; free(Run_Now); Run_Now =NULL; if(!Run_Now) { } else { }

Run_Now->PB.Tc=t;

circle_t[Run_Now->PB.number-1] +=t-Run_Now->PB.arrive_time;

Run_Now = ShortestProcess(PQ); //从就绪队列中调出最短剩余时间进程至队头，

//如果队列为空，转为等待状态

if(IsEmpty(PQ) && k >= N) break; Wait(); continue;

wt[Run_Now->PB.number-1]+=Run_Now->PB.Tc-Run_Now->PB.Tp; printf(\,Run_Now->PB.number);

else {

//如果当前运行进程为空，那么 //如果正好这时有进程入队

if(t == P[i]->PB.arrive_time) { }

k++;

EnQueue(PQ,P[i]); Run_Now = DeQueue(PQ); Run_Now->PB.Tp=t; Run_Now->PB.Tc=t;

//则直接被调入运行队列中

printf(\,Run_Now->P …… 此处隐藏：2356字，全部文档内容请下载后查看。喜欢就下载吧 ……