模拟进程调度_finish,ready,tail,run这些变量的作用?-CSDN博客

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
/*进程控制块数据结构*/
typedef struct node {
	char name[10];/*进程名*/
	int prio;     /*进程优先级*/ 
 	int round;    /*进程分配的时间片*/ 
 	int cputime;  /*进程消耗的CUP时间*/
	int needtime; /*进程需要的CUP时间*/
 	int count;    /*进程运行时间*/
	 char state;   /*进程的状态：'R':运行,'W'：等待,'F'：结束*/
	 struct node *next;/*指向下一个进程的指针*/     
}PCB;
PCB *finish,*ready,*tail,*run;/*指向三个队列的队首的指针，tail为就绪队列的队尾指针*/
int N;/*定义进程的数目*/
/*
函数功能： 将进程就绪队列中第一个放进就绪队列 
函数原型： void firstin(void)
*/
void firstin(void)
{
	if(ready!=NULL){
    		run=ready;
     		ready=ready->next;
     		run->state='R';
     		run->next=NULL;
   	}else{
     		run=NULL;
   	}
}
/*
函数功能：输出进程信息的标题函数 
函数原型：void prt1(char a)
函数参数：char a :a=='p'为优先级，=='r'为时间片轮转 
*/
void prt1(char a)
{
 	if(toupper(a)=='P'){
 		printf(" name  cputime  needtime  priority  state /n");
 	}else{
 		printf(" name  cputime  needtime  count  round  state /n"); 
 	}    
}
/*
函数功能：输出单个进程信息的函数 
函数原型：void prt2(char a,PCB *p)
函数参数：char a :a=='p'为优先级，=='r'为时间片轮转 
          PCB *p 为指向待输出的进程控制块的指针     
*/
void prt2(char a,PCB *p)
{
  	if(toupper(a)=='P'){
   		printf("%-10s,%-10d,%-10d,%-10d,%-5c/n",p->name,p->cputime,p->needtime,p->prio,p->state);
   	}else{
  		printf("%-10s,%-10d,%-10d,%-10d,%-10d,%-5c/n",p->name,p->cputime,p->needtime,p->count,p->round,p->state);
  	}
}

/*
函数功能：输出所有进程信息的函数 
函数原型：void prt(char algo)
函数参数：char a :a=='p'为优先级，=='r'为时间片轮转 
*/
void prt(char algo)
{
  	PCB *p;
  	prt1(algo);
  	if(run!=NULL){
  		prt2(algo,run);
  	}
  
  	p=ready;
  	while(p!=NULL){
   		prt2(algo,p);
   		p=p->next;
  	}
  
  	p=finish;
  	while(p!=NULL){
  		prt2(algo,p);
  		p=p->next;
  	}
  	getchar();
}
 
/*
函数功能：优先级法调度将进程插入到就绪队列算法 
函数原型：void insert1(PCB *q)
函数参数：PCB *q 待插入的队列进程控制块 
          优先级越高，插入越靠前 
*/
void insert1(PCB *q)
{
  	PCB *p,*s,*r; /*p,r用来控制就绪队列滚动，S指向插入的队列*/
  	int b; /*b作为插入控制标志的*/ 
  	s=q;
  	p=ready;
  	r=p;
  	b=1;
  	if(s->prio>=ready->prio){
   		s->next=ready;
  		ready=s;          
  	}else{
   		while((p!=NULL)&&b){
   			if(p->prio>=s->prio){
   				r=p;
   				p=p->next;
  			}else{
     				b=0;
  			}
   		} 
  		s->next=p;
  		r->next=s;
  	}
}

/*
函数功能：时间片轮转算法调度将进程插入到就绪队列算法 
函数原型：void insert2(PCB *q)
函数参数：PCB *q 待插入的队列进程控制块  
*/
 void insert2(PCB *q)
 {
 	tail->next=q;
 	tail=q;
 	q->next=NULL;
 }
/*
函数功能：采用优先级进程调度法时，进程初始化函数 
函数原型：void pcreate_task(char algo)
函数参数：char algo:  

*/
void pcreate_task(char algo)
{
  	PCB *p;
  	int i,time;
  	char na[10];
  	ready=NULL;
  	finish=NULL;
  	run=NULL;
 	for(i=0;i<N;i++){
  		p=(PCB*)malloc(sizeof(PCB));
   		printf("Enter the name of process/n");
  		scanf("%s",na);
   		printf("Enter the time of process/n");
  		scanf("%d",&time);
  		strcpy(p->name,na);
  		p->cputime=0;
  		p->needtime=time;
  		p->state='W';
  		p->prio=time;
  
  		if(ready==NULL){
   			ready=p;
   			ready->next=NULL;
  		}else{
    			insert1(p);
  		}
 		printf("Output the waiting processes information/n");
 		prt(algo);
 	}
 	firstin();
}

/*
函数功能：采用时间片轮转法进程调度法时，进程初始化函数 
函数原型：void rcreate_task(char algo)
函数参数：char algo:  R

*/
void rcreate_task(char algo)
{
  	PCB *p;
 	int i,time;
 	char na[10];
 	ready=NULL;
 	finish=NULL;
 	run=NULL;
 	for(i=0;i<N;i++){
  		p=(PCB*)malloc(sizeof(PCB));
  		printf("Enter the name of process/n");
  		scanf("%s",na);
   		printf("Enter the time of process/n");
  		scanf("%d",&time);
  		strcpy(p->name,na);
  		p->cputime=0;
  		p->needtime=time;
  		p->count=0;
  		p->state='W';
 		p->round=2;
  		if(ready!=NULL){
  			insert2(p);
  		}else{
    			p->next=ready;
    			ready=p;
    			tail=p;
  		}
 		printf("Output the waiting processes information/n");
 		prt(algo);
  	}
 	run=ready;
 	ready=ready->next;
 	run->state='R';
     
}
/*
函数功能：采用优先级进程调度法时，进程调度函数 
函数原型：void priority(char algo)
函数参数：char algo:进程调度类别标志：'P'优先级 'R'时间片轮转 

*/
priority(char algo)
{
  	while(run!=NULL){
  		run->cputime+=1;
  		run->needtime-=1;
  		run->prio-=3;
  		if(run->needtime==0){
      			run->next=finish;
    			finish=run;
   			run->state='F';
   			run=NULL;
      			firstin();        
   		}else{
     			if((ready!=NULL)&&(run->prio<ready->prio)){
      				run->state='W';
      				insert1(run);
      				run=NULL;
      				firstin();
    			}
   		}
 
   		prt(algo);
 	 }
}

/*
函数功能：采用时间片轮转法进程调度法时，进程调度函数 
函数原型：void roundrun(char algo)
函数参数：char algo:  R
*/
void roundrun(char algo)
{
  	while(run!=NULL){
  		run->cputime=run->cputime+1;
  		run->needtime=run->needtime-1;
  		run->count=run->count+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';
      					insert2(run);
      					firstin();
   				}
    			}
   		}
   		prt(algo);
  	}
}

/*main 函数*/

int main()
{
  	char algo;
  	printf("Choose the type of attemper P:priority R:timeround/n");
  	scanf("%c",&algo);
  	printf("Please enter the number of processes N:/n");
  	scanf("%d",&N);
 	if((algo=='P')||(algo=='p')){
   		pcreate_task(algo);
   		priority(algo);
   
 	}else if((algo=='r')||(algo=='R')){
   		rcreate_task(algo);
   		roundrun(algo);
   
 	}
}