操作系统实习——时间片轮转算法的实现

写了这个程序后我对时间片轮转算法有了更深的了解：在算法中系统将所有的就绪进程按先来先服务的原则排成一个队列。每次调度时，把CPU分配给队首进程，并令其执行一个时间片。一直到程序运行完成，每个程序轮流享用着cpu的资源。

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
typedef struct node 
{ 
  char name[20];    
  int round;     
  int cputime; 
  int arrivetime;
  int needtime;   
  char state;     
  int count;     
  struct node *next;   
}PCB; 
PCB *ready=NULL,*run=NULL,*finish=NULL; 
int num,i; 

void GetFirst();    
void Output();     
void InsertTime(PCB *in); 
void InsertFinish(PCB *in);    
void TimeCreate();   
void RoundRun();
   
int main(void) 
{ 
  printf("请输入要创建的进程数目:\n"); 
  scanf("%d",&num);   
    TimeCreate(); 
    RoundRun(); 
  Output(); 
} 
void GetFirst()  /*取得第一个就绪队列节点*/ 
{ 
  run = ready; 
   
  if(ready!=NULL) 
  { 
    run ->state = 'R'; 
    ready = ready ->next; 
    run ->next = NULL; 
  } 
} 
void Output()    /*输出队列信息*/ 
{ 
  PCB *p; 
  p = ready; 
  printf("进程名\tcpu时间\t需要时间\t进程状态\t计数器\n"); 
  while(p!=NULL) 
  { 
    printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->state,p->count); 
    p = p->next; 
  } 
  p = finish; 
  while(p!=NULL) 
  { 
    printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->state,p->count); 
    p = p->next; 
  } 
  p = run; 
  while(p!=NULL) 
  { 
    printf("%s\t%d\t%d\t\t%c\t\t%d\n",p->name,p->cputime,p->needtime,p->state,p->count); 
    p = p->next; 
  } 
} 

void InsertTime(PCB *in)  /*将进程插入到就绪队列尾部*/ 
{ 
  PCB *fst; 
  fst = ready; 
   
  if(ready == NULL) 
  { 
    in->next = ready; 
    ready = in; 
  } 
  else 
  { 
    while(fst->next != NULL) 
    { 
      fst = fst->next; 
    } 
    in ->next = fst ->next; 
    fst ->next = in; 
  } 
} 
void InsertFinish(PCB *in)  /*将进程插入到完成队列尾部*/ 
{ 
  PCB *fst; 
  fst = finish; 
   
  if(finish == NULL) 
  { 
    in->next = finish; 
    finish = in; 
  } 
  else 
  { 
    while(fst->next != NULL) 
    { 
      fst = fst->next; 
    } 
    in ->next = fst ->next; 
    fst ->next = in; 
  } 
} 

void TimeCreate() /*时间片输入函数*/ 
{ 
  PCB *tmp; 
  int i; 
   
  printf("输入进程名字 到达时间 进程所需时间 时间片大小：\n"); 
  for(i = 0;i < num; i++) 
  { 
    if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL) 
    { 
      perror("malloc"); 
      exit(1); 
    } 
    scanf("%s %d %d %d",tmp->name,&(tmp->arrivetime),&(tmp->needtime),&(tmp ->round)); 
    getchar(); 
    tmp ->cputime = 0; 
    tmp ->state ='W'; 
//	tmp->prio=0;
    tmp ->count = 0; 
    InsertTime(tmp); 
  } 
} 

void RoundRun()    /*时间片轮转调度算法*/ 
{ 
   
  int flag = 1; 
   
  GetFirst(); 
  while(run != NULL) 
  { 
    Output(); 
    while(flag) 
    { 
      
      run->cputime++ ; 
      run->needtime--; 
	  run->count++; 
      if(run->needtime == 0) 
      { 
        run ->state = 'F'; 
        InsertFinish(run); 
        flag = 0; 
      } 
      else if(run->count == run->round)
      { 
        run->state = 'W'; 
        run->count=0; 
        InsertTime(run); 
        flag = 0; 
      } 
    } 
    flag = 1; 
    GetFirst(); 
  } 
}

实验测试：