计算机操作系统【进程的调度】

实验一 进程的调度

一、实验目的:
编写和调试一个程序实现进程的调度，以加深对进程的概念和进程调度算法的理解。
二、实验内容：
模拟高优先权优先的进程调度算法
实验原理：
采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程），每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名、优先数、需要运行时间、已用CPU时间、进程状态等等。每个进程的状态可以是就绪W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
进程的优先数及需要的运行时间可以事先人为地指定，进程的运行时间以时间片为单位进行计算。就绪进程获得CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所有进程都完成为止。
三、实验准备：

1. 需求分析：
   系统要求用户先输入进程的数量，然后依次输入每个进程的进程名、优先数、运行所需时间等；程序运行过程中，能依次输出每个时间段内正在运行的进程和正处于就绪队列的进程的各个参数（包括进程名、进程状态、运行所需时间、已运行时间）。

2. 测试数据：（假定优先数越大，优先级越高）
   原始数据：
   进程名 进程优先数 进程需要总运行时间 进程已运行时间
   a 2 2 0
   b 1 1 0
   c 3 2 0
   第一个时间片：c执行；就绪队列：a、b
   进程名 进程优先数 进程需要总运行时间 进程已运行时间
   a 2 2 0
   b 1 1 0
   c 2 2 1
   第二个时间片：a执行；就绪队列：c、b
   进程名 进程优先数 进程需要总运行时间 进程已运行时间
   a 1 2 1
   b 1 1 0
   c 2 2 1
   第三个时间片：c执行；就绪队列：b、a
   （c运行结束）
   进程名 进程优先数 进程需要总运行时间 进程已运行时间
   a 1 2 1
   b 1 1 0
   第四个时间片：b执行；就绪队列：a
   （b运行结束）
   进程名 进程优先数 进程需要总运行时间 进程已运行时间
   a 1 2 1
   第五个时间片，a执行
   （a运行结束）
   四、实验过程：
   1.流程图
   

3. 源代码
   #include <stdio.h>//加载头文件
   #include <stdlib.h>
   #include <conio.h>
   #define getpch(type)(type*)malloc (sizeof(type))
   #define NULL 0
   #include
   #include
   using namespace std;
   struct pcb{/*定义进程控制块PCB /
   char name[10];
   char state;
   int super;
   int ntime;
   int rtime;
   struct pcb link;
   }*ready=NULL,p;
   typedef struct pcb PCB;
   void sort()//采用插入链表结点的方法对所有进程按优先数从大到小的顺序排列，组成就绪队列。（每个结点都要找对插入位置，插入后必须保证链表中结点按从大到小的顺序排列）
   {
   PCBfirst,second;
   int insert=0;
   if((readyNULL)||((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(insert0) first->link=p;
   }
   }
   void input()//建立进程控制块函数
   {
   int i,num;
   cout<<“请输入进程总数：”;
   cin>>num;
   cout<<endl;
   for(i=0;i<num;i++)
   {
   cout<<“进程号No.：”<<i;
   p=getpch(PCB);
   cout<<endl<<“输入进程名：”;
   cin>>p->name;
   cout<<“输入进程优先数：”;
   cin>>p->super;
   cout<<“输入进程运行时间：”;
   scanf(“%d”,&p->ntime);
   cout<<endl;
   p->rtime=0;
   p->state=‘w’;
   p->link=NULL;
   sort();//调用sort函数
   }
   }
   int space()//统计就绪队列（链表）中的进程数（结点数）
   {
   int l=0;
   PCB pr=ready;
   while(pr!=NULL)
   {
   l++;
   pr=pr->link;
   }
   return(1);
   }
   void disp(PCB pr)//建立进程显示函数，用于显示当前进程
   {
   cout<<“qname:”<name;
   cout<<" “<<“state:”<state;
   cout<<” “<<“super:”<super;
   cout<<” “<<“ndtime:”<ntime;
   cout<<” "<<“runtime:”<rtime;
   cout<<endl;
   }
   void check()//建立进程查看函数，依次输出当前正在运行的进程和正处于就绪队列的进程的各个参数
   {
   PCB pr;
   cout<<endl<<“****当前正在运行的进程是：”<name<<endl;//显示当前运行进程
   disp§;
   pr=ready;
   cout<<endl<<“****当前就绪队列状态为：”<name<<endl;//显示就绪队列状态
   while(pr!=NULL)
   {
   disp(pr);
   pr=pr->link;
   }
   }
   void destroy()//进程撤销函数（进程运行结束，撤销进程）
   {
   cout<<endl<<“进程”<name<<“已完成”<<endl;
   free§;
   }
   void running()//对正在运行的进程进行处理：当前正在运行进程的已运行时间加一，若达到所需的运行时间，则撤销进程；否则，优先数-1，插入就绪队列。
   {
   (p->rtime)++;
   if(p->rtime==p->ntime)
   destroy();//调用destroy函数
   else
   {
   (p->super)–;
   p->state=‘w’;
   sort();//调用sort函数
   }
   }
   int main()
   {
   int len,h=0;
   char ch;
   input();
   len=space();
   while((len!=0)&&(ready!=NULL))
   {
   ch=getchar();
   h++;
   cout<<“The extcute number”<<h<<endl;
   p=ready;
   ready=p->link;
   p->link=NULL;
   p->state=‘R’;
   check();
   running();
   cout<<endl<<“按任意键继续…”<<endl;
   ch=getchar();
   }
   cout<<endl<<“进程已经完成”<<endl;
   ch=getchar();
   }

4. 运行界面：
   （1）第一个时间片：c执行；就绪队列：a、b

（2）第二个时间片：a执行；就绪队列：c、b

（3）第三个时间片：c执行；就绪队列：b、a

（4）第四个时间片：b执行；就绪队列：a

（5）第五个时间片，a执行

五、实验心得：
该实验利用进程调度中的优先级算法调度进程，开始给每一个进程设定一个优先级数，对于优先级高的进程先调度，优先级低的进程后调度，在调度一个进程时，其他进程将处于就绪态，而正在被调度的进程应处于运行态。
刚开始接触到实验的时候，不知道该从哪里动笔。后来根据老师的详细讲解，我慢慢地了解了大致的流程。通过这次实验，首先加深了我对进程调度方法和功能的认识，其次让我更加深刻地理解了操作系统中进程调度中优先级调度的基本原理。优先级调度算法只是进程调度算法的一种，我们还应依照书本去学习进程调度的其它算法，以便更好地了解进程调度。