进程管理模拟程序设计总结时间片（进程调度模拟程序）

本文目录

• 进程调度模拟程序
• 如何用C语言编写:设计一个时间片轮转调度算法实现处理机调度的程序
• 求一个时间片进程调度算法！望高手指点！
• “时间片如果进程在时间片结束前结束，则CPU当即进行切换”怎么理解
• 时间片轮转调度设计一个有N个进程并发的进程调度程序每个进程有一

进程调度模拟程序

这几个题是我这学期的操作系统实验里面，变了两个月才弄出来的，现在跟你分享一下（运行过了 没问题的）

先来先服务：c语言编写的

#include 《stdio.h》

#include 《malloc.h》

typedef struct jinchen  //定义结构体

{

 char name;

 int tijiaoshijian;

 int reachtime;

 int runtime;

 int beirun;

 int accomplishtime;

 char state;

 int flag;

 struct jinchen *next;

}PCB;

PCB *finish,*ready;//定义队列 一个完成一个就绪

int time=0;

int t=0;

int num;

void InitPcb()    //进程初始化

{

 int i,j=0;

 PCB *p,*q,*l,*m,*k,*n;

 printf("请输入进程个数:");

 scanf("%d",&num);

 ready=(PCB *)malloc(sizeof(PCB));

 ready-》next=NULL;

 finish=(PCB *)malloc(sizeof(PCB));

 finish-》next=NULL;

 l=(PCB *)malloc(sizeof(PCB));

 l-》next=NULL;

 p=l;

 for(i=0;i《num;i++)

 {

  q=(PCB *)malloc(sizeof(PCB));

  printf("\n进程号 %d:\n",i);

  printf("请输入进程名：");

  scanf("%s",q-》name);

  q-》reachtime=0;

  printf("请输入提交时间：");

  scanf("%d",&(q-》tijiaoshijian));

  printf("请输入运行时间：");

  scanf("%d",&(q-》runtime));

  q-》beirun=q-》runtime;

  q-》state=’R’;

  q-》flag=0;

  if(i!=0)       //链接就绪进程

  {

   //q-》next=NULL;

   q-》next=p-》next;

   p-》next=q;

   p=p-》next;

  }

  else    //第一个进程插入就绪队列

  {

   p-》next=q;

   p=p-》next;

   p-》next=NULL;

  }

 }

 p=l-》next;

 k=ready;

 for(i=0;i《num;i++)   //按照提交时间排序

 {

     q=l-》next;

  t=1000;

  while(q!=NULL)

  {

   if(q-》tijiaoshijian《t&&q-》flag==0)

   {

    t=q-》tijiaoshijian;

    m=(PCB *)malloc(sizeof(PCB));

    m-》next=NULL;

    m-》accomplishtime=q-》accomplishtime;

    m-》beirun=q-》beirun;

    m-》flag=q-》flag;

    for(j=0;j《5;j++)

    m-》name;

    m-》reachtime=q-》reachtime;

    m-》runtime=q-》runtime;

    m-》state=q-》state;

    m-》tijiaoshijian=q-》tijiaoshijian;

    n=q;

   }

  q=q-》next; 

  }

  p=p-》next;

  n-》flag=1;

  m-》flag=1;

  k-》next=m;

  k=k-》next;

 }

 k-》next=NULL;

}

void display()   //函数作用：计算和显示相关输出

{

 PCB *p;

 int m,n=0,k=0,l;

 p=finish-》next;

 while(p!=NULL)

 {

  printf("进程名 :%s",p-》name);

  m=p-》accomplishtime-p-》tijiaoshijian;

  printf("周转时间:%d",m);

  l=m/(p-》beirun);

  printf("带权周转时间:%d",l);

  printf("\n");

  n=m+n;

  k=l+k;

  p=p-》next;

 }

 printf("平均周转时间:%d\n",n/num);

 printf("平均带权周转时间:%d\n",k/num);

}

void Use()//进程调用

{

 int j;

 PCB *p=ready-》next,*k=ready,*q,*n=finish;

 while(k-》next!=NULL)

 {

  p=ready-》next;

  for(j=0;j《num&&p!=NULL;j++)

  { 

   time++;

   //printf("%d\n\n",++t);

   if(p-》reachtime==0) 

    p-》reachtime=time;

   if(p-》state!=’C’)

    {

     printf("正在运行:%s\n",p-》name);

     p-》runtime--;

     if(p-》runtime!=0)    //进程没有运行完，放入队列最后

     {

      q=p;

      while(q-》next!=NULL)

       q=q-》next;

      ready-》next=p-》next;

      q-》next=p;

      p=ready-》next;

      q=q-》next;

      q-》next=NULL;

     }

     else    //进程运行完，放入完成队列

     {

      p-》state=’C’;

      printf("%s进程完成\n",p-》name);

      p-》accomplishtime=time;

      n-》next=p;

      n=p;

      ready-》next=p-》next;

      p-》next=NULL;

     }

    }

  }

 }

}

int main()

{

 PCB *p;

 InitPcb();

 Use();

 display();

 p=finish-》next;

 printf("运行完毕!*说明：已运行完成的进程放入完成队列，未运行完成的进程放在队列最后");

}

运行结果见图

按最高优先级算法：C++程序

#include 《stdio.h》

#include 《stdlib.h》

#include 《conio.h》

#define getpch(type) (type*)malloc(sizeof(type))  

struct pcb{           

 char name;    

 char state;       

 int super;        

 int needtime; 

 int rtime;

 int tijiaotime;  

    int starttime;  

    int ftime; 

    int zztime;

    int dzztime;

 struct pcb* link;    

}*ready=NULL, *p;

typedef struct pcb PCB;   

float pzztime=0;

float pdzztime=0;

int n;

int time=20;

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;

 PCB *q;

 printf("请输入进程数:");

 scanf("%d",&n);

 for(i=0;i《n;i++)

 {

  printf("\n第%d个进程:\n",i);

  p=getpch(struct pcb);

  printf("\n 进程名:");

   scanf("%s",&p-》name);

  printf("\n 优先级:");

  scanf("%d",&p-》super);

  printf("\n 运行时间:");

  scanf("%d",&p-》needtime);

  printf("\n提交时间:");

  scanf("%d",&p-》tijiaotime);

  p-》rtime=0;

  p-》state=’R’;     

  p-》link=NULL;  

 sort();

 }

 q=ready;

}

int space() 

{

 int l=0;

 PCB *pr=ready;    

 while(pr!=NULL)  

 {

  l++;

  pr=pr-》link;

 }

 return(l);

}

void disp(PCB *p2)    

{

time = p2-》tijiaotime 》 time? p2-》tijiaotime:time;

 p2-》starttime=time;

 time+=p2-》needtime;

 p2-》state=’R’; 

 p2-》ftime=time;

 p2-》zztime=p2-》ftime-p2-》tijiaotime;

p2-》dzztime=p2-》zztime/p2-》needtime;

pzztime=p2-》zztime+pzztime;

pdzztime=p2-》dzztime+pdzztime;

 printf("周转时间:%d\n",p-》zztime);

  printf("带权周转时间为 %d\n",p-》dzztime); 

}

void destroy()    

{ 

 free(p);

}

void running()    

{

 p-》rtime=p-》rtime+1;

 if(p-》rtime==p-》needtime)   

 { p-》state=’C’;

 printf("%s",p-》name);

 printf("运行完毕\n");

    disp(p);

  destroy();

 }

 else                    

 {

  (p-》super)++;   

  sort(); 

  printf("正在运行进程%s\n",p-》name);

 }

}

void main()   

{

 int len,h=0;

 input();       

 len=space();   

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

 {

  h++;

  p=ready; 

  ready=p-》link;

  p-》link=NULL;   

  running();  

 }

 pzztime=pzztime/n;

    pdzztime=pdzztime/n;

  printf("\n平均周转时间:%f\n平均带权周转时间为%f\n",pzztime,pdzztime);

}

如何用C语言编写:设计一个时间片轮转调度算法实现处理机调度的程序

实验三 进程调度 一、实验目的 在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。当就绪进程个数大于处理机数时，就必须依照某种策略来决定那些进程优先占用处理机。本实验模拟在单处理机情况下的处理机调度，帮助学生加深了解处理机调度的工作。 二、实验内容 设计一个时间片轮转调度算法实现处理机调度的程序。 三、实验指导 1.实验中使用的数据结构： 1)PCB进程控制块 其中包括参数①进程名name；②要求运行时间runtime；③优先数prior；④状态state；⑤已运行时间runedtime。 2)为简单起见，只设运行队列，就绪链表两种数据结构，进程的调度在这两个队列中切换，如图3.1所示。 图3.1PCB链表 2.运行结果，包括各个进程的运行顺序，每次占用处理机的运行时间 3.每个进程运行时间随机产生，为1~20之间的整数。 4.时间片的大小由实验者自己定义，可为3或5。 四、实验要求 1.在上机前写出全部源程序； 2.能在机器上正确运行程序。 五、程序清单 六、运行结果 七、调试分析及实验心得我的回答和这位老兄的差不多

求一个时间片进程调度算法！望高手指点！

只帮你写点开头，后面你应该会的#include 《stdio.h》#include 《stdlib.h》#include 《string.h》#include 《iostream.h》typedef struct node{char name; int prio; int round; int cputime; int needtime; int count; char state; struct node *next; }PCB;PCB *finish,*ready,*tail,*run,; //队列指针int N; //进程数void zhunbei(){run=ready; //就绪队列头指针赋值给运行头指针run-》state=’G’; //进程状态变为运行态]ready=ready-》next; //就绪队列头指针后移到下一进程}//输出标题函数void output1(char a){if(toupper(a)==’P’) //优先级法 cout《《" "《《endl;cout《《"进程名 占用CPU时间 已运行时间 还要的时间 轮转时间片 状态"《《endl;}

“时间片如果进程在时间片结束前结束，则CPU当即进行切换”怎么理解

　　时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片，即该进程允许运行的时间，使各个程序从表面上看是同时进行的。　　如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。而不会造成CPU资源浪费。　　在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。但在微观上：由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。

时间片轮转调度设计一个有N个进程并发的进程调度程序每个进程有一

cpu进程调度模拟四个队列是优先级队列（优先级高的在前面）可以使用结构体做队列的节点时间片轮转就是指定一个执行时间，时间一到就处理下一个进程，将当前进程进行状态转换（也就是换着状态需要向其放入相应的队列中，优先级队列）理清头绪的话程序不算太复杂但也很麻烦