进程调度模拟程序

Posted 2023-04-12

进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
等待I/O的时间以时间片为单位进行计算，可随机产生，也可事先指定。
每个进程的状态可以是就绪 R（Ready）、运行R（Run）、等待（Wait）或完成F（Finish）四种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、等待进程以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
用C或C++

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

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

#include <stdio.h>

#include <malloc.h>

typedef struct jinchen  //定义结构体

 char name[5];

 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[j]=q->name[j];

    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[5];    

 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);

 

参考技术A #include<windows.h>
#include<iostream.h>
#include<string.h>
#define P_NUM 3 //进程数
#define P_TIME 1//时间片长度
#define MIN -9999
enum state //进程状态

ready, //就绪
run, //执行
wait, //阻塞
finish //完成
;
class Pcb

public:
static void print();
~Pcb();
protected:
char* name; //进程名
int allTime; //需要运行时间
int cpuTime; //已用cpu时间
state process; //进程状态
;

class HPcb:public Pcb

public:
static void print();
static void highS();
static int getFirst();
private:
int firstNum;

;

HPcb hpcb[P_NUM];

class FPcb:public Pcb

public:
static void print();
static void fcfs();
private:
int comeTime;
;

FPcb fpcb[P_NUM];

int HPcb::getFirst() //得到优先级最高的进程

int k=0;
for(int i=1;i<P_NUM;i++)
if(hpcb[k].firstNum<hpcb[i].firstNum)
k=i;
return k;


void HPcb::highS() //最高优先数优先的调度算法

int ii,f,i=0;
for(;i<P_NUM;i++)

char* ch;
ch=new char[1];
cout<<"请输入第"<<i+1<<"个进程的“进程名”、“优先数”、“需要运行的时间”："<<endl;
cin>>ch;
hpcb[i].name=new char[strlen(ch)+1];
strcpy(hpcb[i].name,ch);
cin>>hpcb[i].firstNum>>hpcb[i].allTime;
hpcb[i].cpuTime=0;
hpcb[i].process=ready;

do

f=getFirst();
hpcb[f].cpuTime+=P_TIME;
hpcb[f].firstNum--;
hpcb[f].process=run;
if(hpcb[f].cpuTime>=hpcb[f].allTime)//该进程执行完成

hpcb[f].firstNum=MIN;
hpcb[f].process=finish;
hpcb[f].cpuTime=hpcb[f].allTime;//防止所用时间超过总的时间
system("cls");
print();
Sleep(1000);

else

hpcb[f].firstNum++;//为了输出改变前的相关信息
system("cls");
print();
Sleep(1000);
hpcb[f].firstNum--;
hpcb[f].process=ready;

for(ii=0;ii<P_NUM;ii++)//用于判断是否还有进程未完成
if(hpcb[ii].firstNum!=MIN)
break;
while(ii<P_NUM);//还有进程未完成
cout<<"所有进程已运行完成！"<<endl;



Pcb::~Pcb()

delete [] name;


void FPcb::fcfs() //先来先服务算法

int i=0;
for(;i<P_NUM;i++)

char* ch;
ch=new char[1];
cout<<"请输入第"<<i+1<<"个进程的“进程名”、“需要运行的时间”："<<endl;
cin>>ch;
fpcb[i].name=new char[strlen(ch)+1];
strcpy(fpcb[i].name,ch);
cin>>fpcb[i].allTime;
fpcb[i].comeTime=i+1;
fpcb[i].cpuTime=0;
fpcb[i].process=ready;

for(i=0;i<P_NUM;i++) //P_NUM个进程

for(int j=0;j<fpcb[i].allTime;j+=P_TIME) //每个进程所用时间

fpcb[i].cpuTime+=P_TIME; //第i个进程所用时间加1个时间片
if(fpcb[i].cpuTime<fpcb[i].allTime) //第i个进程还未完成
fpcb[i].process=run; //将其状态设为就绪态
else

fpcb[i].cpuTime=fpcb[i].allTime; //防止所用时间超过总时间，因为时间片不定
fpcb[i].process=finish; //将状态设为完成态

if(j+P_TIME>=fpcb[i].allTime)

if((i+1)!=P_NUM) //如果第i+1个进程不是最后一个进程

fpcb[i+1].cpuTime=fpcb[i].cpuTime-fpcb[i].allTime;
fpcb[i].cpuTime=fpcb[i].allTime;
fpcb[i].process=finish;
fpcb[i+1].process=run;


else

fpcb[i].process=finish;
fpcb[i].cpuTime=fpcb[i].allTime;


system("cls");
print();
Sleep(1000);


cout<<"所有进程已运行完成！"<<endl;


void HPcb::print()

cout<<"*********************************************************************"<<endl;
cout<<"进程名"<<"\t"<<"还需运行时间\t"<<"已用CPU时间"<<"\t"<<"优先级"<<"\t"<<"状态"<<endl;
for(int i=0;i<P_NUM;i++)

cout<<hpcb[i].name<<"\t\t"<<hpcb[i].allTime-hpcb[i].cpuTime<<"\t\t"<<hpcb[i].cpuTime<<"\t"<<hpcb[i].firstNum<<"\t";
switch(hpcb[i].process)

case wait:cout<<"阻塞态"<<endl;break;
case ready:cout<<"就绪态"<<endl;break;
case run:cout<<"运行态"<<endl;break;
case finish:cout<<"完成态"<<endl;break;


cout<<"---------------------------------------------------------------------"<<endl;
cout<<endl;


void FPcb::print()

cout<<"*********************************************************************"<<endl;
cout<<"进程名"<<"\t"<<"还需运行时间\t"<<"已用CPU时间"<<"\t"<<"状态"<<endl;
for(int i=0;i<P_NUM;i++)

cout<<fpcb[i].name<<"\t\t"<<fpcb[i].allTime-fpcb[i].cpuTime<<"\t\t"<<fpcb[i].cpuTime<<"\t";
switch(fpcb[i].process)

case wait:cout<<"阻塞态"<<endl;break;
case ready:cout<<"就绪态"<<endl;break;
case run:cout<<"运行态"<<endl;break;
case finish:cout<<"完成态"<<endl;break;


cout<<"---------------------------------------------------------------------"<<endl;
cout<<endl;


int main()

char ch;
cout<<"请选择算法：\n1. 先来先服务算法\n2. 最高优先数优先的调度算法\n0. 退出"<<endl;
cin>>ch;
if(ch=='1')
FPcb::fcfs();
else if(ch=='2')
HPcb::highS();
return 0;
本回答被提问者采纳

一个简单的模拟进程调度的C++程序

这是我们操作系统实验课的一个实验程序，模拟简单的若干个进程在执行态和就绪态之间的变动。

我根据实验指导书上给出的程序进行了一点修改。

 

#include<cstdio>
#include<cstdlib>

struct PCB
{
    char name[10];
    char state; //状态
    int super; //优先级
    int ntime; //预计运行时间
    int rtime; //实际运行时间
    PCB *link;
}*ready=NULL, *p;

void disp(PCB *pr) /*建立进程显示函数,用于显示当前进程 */
{
    printf("\n qname \t state \t super \t ntime \t rtime \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");
}

void check() /* 建立进程查看函数 */
{
    printf("\n ******** 当前正在运行的进程是:%s",p->name); /* 显示当前运行进程 */
    disp(p);

    printf("\n ******** 当前就绪队列状态为:\n"); /* 显示就绪队列状态 */
    PCB *pr=ready;
    while(pr!=NULL) disp(pr), pr=pr->link;
}

void sort() /* 建立对进程进行优先级排列函数 */
{
    if(ready==NULL || (p->super)>(ready->super)) /* 优先级最大者,插入队首 */
    {
        p->link=ready;
        ready=p;
    }
    else /* 进程比较优先级,插入适当的位置中 */
    {
        PCB *first=ready, *second=first->link;
        while(second!=NULL)
        {
            if((p->super)>(second->super)) /* 若插入进程比当前进程优先数大,插入到当前进程前面 */
            {
                first->link=p;
                p->link=second;
                return;
            }

            first=first->link;
            second=second->link;
        }
        first->link=p;
    }
}

void input() /* 建立进程控制块函数 */
{
    system("cls");

    printf("\n 请输入进程数目?");
    int num; scanf("%d",&num);

    for(int i=0;i<num;i++)
    {
        printf("\n 进程号 No.%d:\n",i);
        p=(PCB *)malloc(sizeof(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 函数 */
    }

    system("cls");
    printf("\n ******** 进程创建如下:\n");
    PCB *pr=ready;
    while(pr!=NULL) disp(pr), pr=pr->link;
}

inline void destroy() /*建立进程撤消函数(进程运行结束,撤消进程) */
{
    printf("\n 进程 [%s] 已完成.\n",p->name), free(p);
}

inline void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态) */
{
    (p->rtime)++;
    if(p->rtime==p->ntime)
        destroy(); /* 调用 destroy 函数 */
    else
        --(p->super), p->state=‘w‘, sort();
}

int main() /*主函数*/
{
    input();

    int h=0;
    while(ready!=NULL)
    {
        getchar();
        printf("\n The execute number:%d \n",++h);

        p=ready;
        ready=p->link;
        p->link=NULL;
        p->state=‘r‘;

        check();
        running();

        printf("\n 按任意键继续......"), getchar();
    }

    printf("\n\n 进程已经全部完成.\n");
    getchar();

    return 0;
}

/*
3
A
3
5
B
2
3
C
1
4
*/