操作系统编程进程或作业先来先服务、高优先权、按时间片轮转调度算法

（售后服务）操作系统编程进程或作业先来先服务高优先权按时间片轮转调度算法湖南农业大学科学技术师范学院学生实验报告（高优先权流程图）（按时间片轮转调度）程序说明及实现:1)先来先服务调度算法：高响应比优先实现进程调度.(用C语言实现),2)优先级调度程序：该程序由主程序、构造队列子程序、打印子程序、运行子程序构成。

3)时间片轮转法程序：于此程序中由于程序比较小，未进行分模块设计。

直接采用单壹模块。

1先来先服务＃include<stdio.h> floatt,d;/*定义俩个全局变量*/struct/*定义壹个结构体数组，包括进程的信息*/{intid;floatArriveTime;floatRequestTime;floatStartTime;floatEndTime;floatRunTime;floatDQRunTime;intStatus;}arrayT ask[4];/*定义初始化的结构体数组*/GetTask()/*给结构体数组赋值，输入到达，服务时间*/{inti;floata;for(i=0;i<4;i++){arrayT ask[i].id=i+1;printf("inputthenumber");printf("inputthetheArriveTimeofarrayT ask[%d]:",i);/*用户输入进程的时间，初始为零*/scanf("%f",&a);arrayT ask[i].ArriveTime=a;printf("inputtheRequestTimeofarrayT ask[%d]:",i);scanf("%f",&a);arrayT ask[i].RequestTime=a;arrayT ask[i].StartTime=0;arrayT ask[i].EndTime=0;arrayT ask[i].RunTime=0;。

第6章设备管理习题与解答6.1 例题解析例6.2.1 何谓虚拟设备？请说明SPOOLing系统是如何实现虚拟设备的。

解本题的考核要点是虚拟设备的实现方法。

虚拟设备是指利用软件方法，比如SPOOLing系统，把独享设备分割为若干台逻辑上的独占的设备，使用户感受到系统有出若干独占设备在运行。

当然，系统中至少一台拥有物理设备，这是虚拟设备技术的基础。

SPOOLing系统又称“假脱机I/O系统”，其中心思想是，让共享的、高速的、大容量外存储器（比如，磁盘）来模拟若干台独占设备，使系统中的一台或少数几台独占设备变成多台可并行使用的虚拟设备。

SPOOLing系统主要管理外存上的输入井和输出井，以及内存中的输入缓冲区和输出缓冲区。

其管理进程主要有输入和输出进程，负责将输入数据装入到输入井，或者将输出井的数据送出。

它的特点是：提高了 I/O操作的速度；将独占设备改造为共享设备；实现了虚拟设备功能。

例 6.2.2 有关设备管理要领的下列叙述中，( )是不正确的。

A．通道是处理输入、输出的软件B．所有外围设备都由系统统一来管理C．来自通道的I/O中断事件由设备管理负责处理D．编制好的通道程序是存放在主存贮器中的E．由用户给出的设备编号是设备的绝对号解本题的考核要点是设备管理的基本概念。

(1) 通道是计算机上配置的一种专门用于输入输出的设备，是硬件的组成部分。

因此A是错误的。

(2) 目前常见I/O系统其外部设备的驱动和输入输出都由系统统一管理。

因此B是对的。

(3) 设备管理模块中的底层软件中配有专门处理设备中断的处理程序。

通道中断属于设备中断的一种。

因此C是对的。

(4) 通道设备自身只配有一个简单的处理装置（CPU），并不配有存储器，它所运行的通道程序全部来自内存。

因此D是对的。

(5) 系统在初启时为每台物理设备赋予一个绝对号，设备绝对号是相互独立的。

由用户给出的设备号只能是逻辑编号，由系统将逻辑号映射为绝对号。

因此E是错误的。

操作系统考点第一章：1，操作系统的定义（简述）：操作系统是一组用于控制和管理计算机系统中所有资源的程序的集合，其任务是合理的组织计算机的工作流程，有效的组织诸资源协调一致的工作以完成各种任务，从何达到充分发挥资源效率方便用户使用计算机的目的。

2，操作系统的功能：<六大点要记得，下面的小点只要记得部分>（1）处理机管理，包括a 进程控制和管理b进程的同步和互斥c进程通信d进程死锁e线程控制和管理f处理器调度（2）存储管理，包括a存储分配b存储共享c地址转换与存储保护d存储扩充（3）设备管理，包括a提供I/O设备的控制与管理b提供缓冲区的管理c提供设备的独立性d外围设备的分配和去配e实现共享性I/O设备的驱动调度f实现虚拟设备（4）文件管理a提供文件逻辑组织方法b提供文件物理组织方法c提供文件存取方法d提供文件使用方法e实现文件的目录管理f实现文件的共享和存取控制g实现文件的存储空间管理（5）网络管理a网上资源管理功能b数据通信管理功能c网络管理功能（6）提供的良好的用户界面，她是直接关系到操作系统能否得到用户认可的一个关键问题。

3，操作系统的特性：（1）并发性（2）共享性（3）不确定性（4）虚拟性（区别并发与并行）4，通道是一种专用处理部件，它能控制一台或者多台外设工作，负责外部设备和内存之间的信息传输。

（注;主机与I/O之间并行程度最高的方式就是通道）第二章：1，操作系统可以通过程序接口和操作接口两种方式把它的服务和功能提供给用户。

程序接口也称应用程序接口（API）2，系统调用他是用户程序或者其他系统程序获得操作系统服务的唯一途径。

第三章：1，中断的概念：中断是指CPU对系统中或系统外发生异步事件的响应。

2，进程是为了描述程序在并发执行时对系统资源的共享，所需的一个描述程序执行时动态特征的概念。

进程是具有独立功能的程序关于某个数据集合上的一个运动活动，是系统进行资源分配，调度和保护的独立单位3，（注意：七状态转换的条件，例如激活是将什么状态转换为什么状态4，PCB（进程控制块）是系统感知进程存在的唯一标志。

#include"stdio.h"#define N 50int n;int sj;struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int yxj; //优先级int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];void input(Gzuo a[]){printf("请输入进程个数：");scanf("%d",&n);for(int i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sj);}void sjp(Gzuo a[],int sj)//时间片轮转调度{int i,j,min,time;float sum1,sum2;bool flag=true;/*printf("\t请输入进程数(0<n<=50):\t"); scanf("%d",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);printf("\n\n");printf("\t请输入时间片大小(0<sjp):\t"); scanf("%d",&sjp);while(sjp<=0){printf("n\t请重新输入：");scanf("%d",&sjp);}/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻int st2; //标志是否完成float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);a[i].st2 = a[i].st;printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].st2;a[i].st2=a[i+1].st2;a[i+1].st2=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}time = a[0].dt;//printf("赋值后TIME值为：%d\n",time);min = 0;while(min<n){flag=true;for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt<=time)flag=false;}for(i=0;i<n;i++){if(a[i].st2 > 0 ){if(a[i].dt<=time){//printf("当前a[%d].st2值为：%d\n",i,a[i].st2);a[i].st2 = a[i].st2 - sj;//printf("运算后当前a[%d].st2值为：%d\n",i,a[i].st2); //printf("当前TIME值为：%d\n",time);time = time + sj;//printf("增加之后TIME值为：%d\n",time);if(a[i].st2<=0){a[i].wct = time + a[i].st2;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;min++;}}else if(flag)for(i=0;i<n;i++){if(a[i].st2>0&&a[i].dt>time){time = a[i].dt;break;}}}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("**************************************************************** *****\n");}void fcfs(Gzuo a[])//先到先服务调度{int i,j,min;float sum1,sum2;/*printf("\t请输入进程数(0<n<=50):\t");scanf("%d",&n);while(n>50||n<=0)printf("n\t请重新输入："); scanf("%d",&n);}printf("\n\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt);a[i].dczt=a[i].zt/a[i].st;}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt ,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void sjf(Gzuo a[])//短作业优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t"); scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/*struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间};Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间：");scanf("%d",&a[i].dt);printf("\t服务时间：");scanf("%d",&a[i].st);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}if(a[i].dt==a[i+1].dt&&a[i].st>a[i+1].st) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b=b+1;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].st>a[i+1].st){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].st>a[z+1].st){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t完成时间\t周转时间\t带权周转时间\n");sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%.0f\t\t%.2f\n",a[i].id,a[i].dt,a[i].st,a[i].wct,a[i].zt, a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void yxj(Gzuo a[])//优先级优先调度{int i,j,min;int b=0,z;float sum1,sum2;/*printf("\n\t\t请输入进程数(0<n<=50):\t");scanf("%d/n",&n);while(n>50||n<=0){printf("n\t请重新输入：");scanf("%d",&n);}printf("\n");/* struct Gzuo{int id; //进程名字int dt; //到达时刻int st; //服务时间int yxj; //优先级int wct; //完成时刻float zt; //周转时间float dczt; //带权周转时间 };Gzuo a[N];for(i=0;i<n;i++){a[i].id=i+1;printf("\t到达时间："); scanf("%d",&a[i].dt);printf("\t服务时间："); scanf("%d",&a[i].st);printf("\t优先级：");scanf("%d",&a[i].yxj);printf("\n");}*/min=a[0].dt;for(j=n-1;j>=0;j--){for(i=0;i<j;i++){if(a[i].dt>a[i+1].dt){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min; min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}if(a[i].dt==a[i+1].dt&&a[i].yxj<a[i+1].yxj) {min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}a[0].wct=a[0].st+a[0].dt;a[0].zt=(float)a[0].st;a[0].dczt=a[0].zt/a[0].st;for(i=1;i<n;i++){if(a[i].dt>a[0].wct) ;else b++;}for(j=b-1;j>=1;j--){for(i=1;i<j;i++){if(a[i].yxj<a[i+1].yxj){min=a[i].dt;a[i].dt=a[i+1].dt;a[i+1].dt=min;min=a[i].st;a[i].st=a[i+1].st;a[i+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;min=a[i].yxj;a[i].yxj=a[i+1].yxj;a[i+1].yxj=min;}}}for(i=1;i<n;i++){if(a[i].dt>a[i-1].wct){a[i].wct=a[i].dt+a[i].st;a[i].zt=(float)a[i].st;a[i].dczt=a[i].zt/a[i].st;}else{a[i].wct=a[i-1].wct+a[i].st;a[i].zt=(float)(a[i].wct-a[i].dt); a[i].dczt=a[i].zt/a[i].st;}for(j=i+1,b=j;j<n;j++){if(a[j].dt>a[i].wct) ;else b=b+1;}for(j=b-1;j>=i;j--){for(z=i;z<j;z++){if(a[z].yxj<a[z+1].yxj){min=a[z].dt;a[z].dt=a[z+1].dt;a[z+1].dt=min;min=a[z].st;a[z].st=a[z+1].st;a[z+1].st=min;min=a[i].id;a[i].id=a[i+1].id;a[i+1].id=min;}}}}printf("\n进程：到达时间\t服务时间\t优先级\t完成时间\t周转时间\t带权周转时间\n"); sum1=0;sum2=0;for(j=0;j<n;j++){ for(i=0;i<n;i++)if(a[i].id==j+1){printf("%d：%d\t\t%d\t\t%d\t\t%d\t\t%.0f\t%.2f\n",a[i].id,a[i].dt,a[i].yxj,a[i].st,a[i ].wct,a[i].zt,a[i].dczt);sum1+=a[i].zt;sum2+=a[i].dczt;}}printf("****************************************************************** ***\n");}void main(){ int n;input(a);printf("以下是先到先服务调度：");fcfs(a);printf("以下是短作业优先调度：");sjf(a);printf("以下是时间片轮转法：");sjp(a,sj);printf("以下是优先级优先调度：");yxj(a); }。

第四章一、单项选择题1．为了根据进程的紧迫性做进程调度，应采用(B )。

A．先来先服务调度算法 B. 优先数调度算法 C．时间片轮转调度法 D．分级调度算法2．采用时间片轮转法调度是为了( A)。

A．多个终端都能得到系统的及时响应 B．先来先服务C. 优先数高的进程先使用处理器 D．紧急事件优先处理3．采用优先数调度算法时，对那些具有相同优先数的进程再按( A )的次序分配处理器。

A 先来先服务 B. 时间片轮转 C. 运行时间长短 D．使用外围设备多少4. 当一进程运行时，系统强行将其撤下，让另一个更高优先数的进程占用处理器，这种调度方式是( B )。

A. 非抢占方式B．抢占方式 C. 中断方式 D．查询方式5．( B)必定会引起进程切换。

A．一个进程被创建后进入就绪态B．一个进程从运行态变成阻塞态C．一个进程从阻塞态变成就绪态6.( B)只考虑用户估计的计算机时间，可能使计算时间长的作业等待太久。

A．先来先服务算法B．计算时间短的作业优先算法C．响应比最高者优先算法 D．优先数算法7．先来先服务算法以( A )去选作业，可能会使计算时间短的作业等待时间过长。

A．进入的先后次序 B．计算时间的长短 C．响应比的高低 D．优先数的大小8．可以证明，采用( C )能使平均等待时间最小。

A.优先数调度算法 B．均衡调度算法C．计算时间短的作业优先算法 D．响应比最高者优先算法9．在进行作业调度时．要想兼顾作业等待时间和计算时间，应选取(D )。

A均衡调度算法 B．优先数调度算法C．先来先服务算法D．响应比最高者优先算法10．作业调度算法提到的响应比是指( B )。

A．作业计算时间与等待时间之比B．作业等待时间与计算时间之比C．系统调度时间与作业等待时间之比 D．作业等待时间与系统调度时间之比11．作业调度选择一个作业装入主存后，该作业能否占用处理器必须由( D )来决定。

A．设备管理 B．作业控制 C．驱动调度D．进程调度12．系统出现死锁的根本原因是( D )。

进程调度模拟设计——先来先服务、优先级法学号：课程设计题目进程调度模拟设计——先来先服务、优先级法学院计算机科学与技术专业班级姓名指导教师吴利军2013 年 1 月16 日课程设计任务书学生姓名：专业班级：指导教师：吴利军工作单位：计算机科学与技术学院题目: 进程调度模拟设计——先来先服务、优先级法初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。

2．实践准备：掌握一种计算机高级语言的使用。

要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。

2．设计报告内容应说明：⑴需求分析；⑵功能设计（数据结构及模块说明）；⑶开发平台及源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；时间安排：设计安排一周：周1、周2：完成程序分析及设计。

周2、周3：完成程序调试及测试。

周4、周5：验收、撰写课程设计报告。

（注意事项：严禁抄袭，一旦发现，一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日进程调度模拟设计——先来先服务、优先级法1、背景：当计算机系统是多道程序设计系统时，通常会有多个进程或线程同时竞争CPU。

只要有两个或更多的进程处于就绪状态，这种情形就会发生。

如果只有一个CPU可用，那么就必须选择下一个要运行的进程。

在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法成为调度算法。

作业调度算法: 先来先服务算法、短作业优先算法引言在计算机操作系统中，作业调度算法是一种重要的技术，用于管理和调度计算机系统中的作业。

作业调度算法决定了如何分配计算机资源，以便最大化系统的效率和吞吐量。

本文将介绍两种常见的作业调度算法：先来先服务算法（First Come First Serve，FCFS）和短作业优先算法（Shortest Job First，SJF）。

先来先服务算法（FCFS）先来先服务算法是最简单的作业调度算法之一。

按照作业提交的顺序进行调度，先提交的作业先执行，后提交的作业则等待。

这种调度算法不考虑作业的执行时间或优先级，只根据作业提交的先后顺序来进行调度。

算法流程1.将作业按照提交的先后顺序排列。

2.按照排列顺序执行作业。

优点•算法实现简单，易于理解和实现。

•适用于短作业或者作业提交顺序代表了作业的优先级的情况。

缺点•短作业可能因为长作业的存在而等待时间过长，导致响应时间较长。

•不考虑作业执行时间，可能导致平均等待时间和平均周转时间较长。

•无法适应不同作业的执行时间需求。

短作业优先算法（SJF）短作业优先算法是一种将作业按照执行时间长度进行排序的作业调度算法。

在短作业优先算法中，最短执行时间的作业先执行，以此类推。

该算法可以最大程度地减少作业的等待时间和周转时间。

算法流程1.将作业按照执行时间长度从短到长进行排序。

2.按照排列顺序执行作业。

优点•可以最大程度地减少作业的等待时间和周转时间。

•适用于短作业和长作业相互混合的情况。

缺点•难以准确估计作业的执行时间，可能导致长作业等待时间过长。

•需要预先知道作业的执行时间长度才能进行排序。

•不适用于长作业占主导地位的情况。

性能对比与选择先来先服务算法和短作业优先算法都有其优点和缺点。

选择合适的算法取决于具体的应用场景和需求。

•如果作业都很短，并且没有严格的截止时间要求，先来先服务算法可以简单高效地满足需求。

•如果作业的执行时间非常重要，并且具有较严格的截止时间要求，短作业优先算法可以最大程度地减少作业的等待时间和周转时间。

先来先服务,时间片调度,优先级调度算法实验报告先来先服务、时间片调度、优先级调度算法实验报告1. 引言本次实验旨在研究和比较先来先服务（FCFS）、时间片调度（RR）和优先级调度（Priority Scheduling）三种常见的进程调度算法。

进程调度是操作系统中的重要概念之一，合理的进程调度算法可以提高系统效率，优化资源利用。

2. 先来先服务算法•先来先服务算法是一种简单的调度算法，按照进程到达的顺序进行调度。

•优点：简单易实现，适用于长作业。

•缺点：容易造成短作业等待时间过长，无法满足实时性要求。

3. 时间片调度算法•时间片调度算法将CPU时间划分为一段一段的时间片，每个进程在一个时间片内执行。

•若进程未完成，会被放入就绪队列的末尾，等待下一个时间片。

•优点：公平，适用于短作业，能满足实时性要求。

•缺点：时间片过长，会导致长作业等待时间过长。

4. 优先级调度算法•优先级调度算法根据进程的优先级来确定调度顺序，拥有最高优先级的进程先执行。

•静态优先级可在创建进程时确定，动态优先级可根据进程执行情况进行调整。

•优点：适用于实时任务和长作业，可根据需求调整优先级。

•缺点：可能导致低优先级任务等待时间过长，存在优先级反转问题。

5. 实验结果与分析通过对三种调度算法的实验测试，得出以下结论：•FCFS算法在长作业的情况下表现较好，但对于短作业不友好，容易造成长时间等待；•RR算法适用于短作业，能保证公平性，但时间片过长可能导致长作业等待时间过长；•优先级调度算法较为灵活，能满足实时性要求，但可能导致低优先级任务长时间等待。

综上所述，不同的调度算法适用于不同的场景，根据需求选择合适的算法可提高系统效率。

6. 总结本次实验对先来先服务、时间片调度和优先级调度算法进行了研究和比较。

通过对三种算法的分析，我们可以根据任务特点和需求选择合适的调度算法，以提高系统的效率和资源利用率。

同时，在实际应用中也需要考虑进程的实时性要求，避免长时间等待等问题的出现。

填空题1.操作系统的特征是（并发）,（共享）和（异步性）还有（虚拟）.2.按照用户界面的使用环境和功能特征的不同,一般可以把操作系统分为三种基本类型,即:（批处理系统）,（分时系统）和实时系统.3. 软件系统分为系统软件,（支撑软件）和（应用软件）.4.多数计算机系统将处理器的工作状态划分为（管态）和目态.后者一般指用户程序运行时的状态,又称为普通态或（用户态）.5. 存储器一般分成高速缓冲器,（内存）和（外存）三个层次,其中高速缓冲器是造价最高,存取速度最快.6.文件的物理结构有:顺序结构,（链接结构）和（索引结构）.8. 在单CPU系统中有n(n>1)个进程,在任一时刻处于就绪的进程最多是（n-1）个,最少是（0）个.9. 系统为每一台设备确定一个编号,以便区分和识别,这个确定的编号称为设备的（绝对）号.由用户在程序中定义的设备编号称为设备的（相对）号.10. 一个作业可划分成若干个（相对独立）的部分,每个部分称为一个（作业步）.11. 在批处理兼分时的系统中,往往由分时系统控制的作业称为（前台）作业,而由批处理系统控制的作业称为（后台）作业.12. 操作系统为用户提供两种类型的使用接口,它们是（操作员)接口和（程序员) 接口.13. 操作系统中,进程可以分为（系统）进程和（用户）进程两类.15. 除了新建状态与撤销状态，进程的基本状态有(运行)、（就绪）、（阻塞）。

16. 在响应比最高者优先的作业调度算法中,当各个作业等待时间相同时,（计算时间短）分母的作业将得到优先调度;当各个作业要求运行的时间相同时, （等待时间长）分子的作业得到优先调度.17. 当一个进程独占处理器顺序执行时,具有两个特性: （封闭）性和（可再现性）.18. Linux的shell有两层含义,一是指由（shell命令）组成的Shell 命令语言;二是指（该命令的解释）程序.19. 操作系统的主要设计目标是（方便用户使用）和（资源利用率高）.20. 当一个进程完成了特定的任务后,系统收回这个进程所占的（资源）和取消该进程的（进程控制块PCB），就撤消了该进程.21. 每个索引文件都必须有一张（索引）表,其中每个登记项用来指出一个逻辑记录的（存放位置或指针或首地址）.22. 实现SPOOL系统时必须在磁盘上辟出称为（输入#）和（输出#)的专门区域,以存放作业信息和作业执行结果.23. 一个理想的作业调度算法应该是既能（提高系统效率）又能使进入系统的作业（周转时间短）.24. 死锁的四个必要条件是（互斥使用资源）,（占用并等待资源）,不可抢夺资源和循环等待资源.25. 操作系统一般为用户提供了三种界面,它们是(命令界面),(图形界面)和系统调用界面.26. 进程间相互合作的关系是(同步)关系,而对资源争用的关系是(互斥)关系.若干进程使用同一临界资源时必须互斥执行.27. 处理机调度可分为三级,它们是作业调度,(进程调度)和CPU交换调度;在一般操作系统中,必须具备的调度是(进程调度).28. 一般说来,用户程序中所使用的地址是逻辑地址,而内存中各存储单元的地址是(物理地址或绝对地址);将前者转变为后者的过程称作(重定位).29. 在段页式存储管理系统中,面向(用户)的地址空间是段式划分,面向(物理实现)的地址空间是页式划分.30. 在Linux系统中,基本的文件类型分为(普通)文件,目录文件和文件, 所有的I/O设备按其物理特性分为(字符)设备和块设备.33. 操作系统的设备管理应具备的主要功能是(监视设备状态),(进行设备分配),完成I/O操作和缓冲管理与地址转换.34. 对信号量S每执行一次P操作,则信号量S的值就减1.当S的值小于0时,执行P操作的进程的状态就置为阻塞态,把相应的PCB连入该信号量队列的(末尾),并且该进程放弃处理机,由(进程调度程序)调度合适进程.35. 把逻辑地址转变为内存的物理地址的过程称作重定位,它分为(静态重定位)和(动态重定位)两种形式,在现代操作系统中都采用动态重定位形式来实现这种地址转换.37. SPOOLing的中文含义为（同时外围联机操作）或（假脱机操作）。

第一章一、选择题1. D2. C 3,B 4.B 5.B6. A7. B 8,D 9.A 10.C11. A 12. A 13,D 14.B 15.A二、填空题1. 硬件、软件2. 交互性、多路性和独占性3.雨提高系统的工作效率4.处理器管理、存储器管理、文件管理、设备管理和接口管理。

5. 程序级和用户组（程序接口和命令接口）。

三、简答题1.计算机系统由哪些部分组成?处理器管理、存储器管理、文件管理、设备管理和接口管理2. 什么是操作系统？（1）管理和控制计算机的硬件和软件资源。

（2）合理组织计算机工作流程。

（3）提供方便用户操作的接口的软件。

3. 实时操作系统的主要特点是什么?及时性、可靠性。

4. 从资源管理的角度来看，操作系统的基本功能可分成哪些部分? 管理和控制计算机的硬件和软件资源。

5. 操作系统的分类？（1）批处理操作系统。

（2）实时操作系统。

（3）分时操作系统。

（4）网络操作系统。

（5）分布式操作系统。

（6）嵌入式操作系统。

（7）微型计算机操作系统。

第二章一、选择题1. D2. B 3,D 4.B 5.B6. A7. B 8,D 9.A 10.C11. B 12. B 13,B 14.B 15.D16. A 17. D 18,A 19.C 20.D21. B 22. D 23,D 24.D二、填空题1. 动态和静态。

2. 程序、数据和PCB（进程控制块）3. 程序、数据和PCB（进程控制块、PCB、程序段。

4. 动态、静态5. 4,06. 高级调度(高级)。

按照某调度算法从后备队列中选取作业7.平均吞吐量、所能忍受的响应时间、系统资源的利用率。

8.操作系统9.收容、运行、完成三、简答题1. 什么叫多道程序设计?为什么要采用多道程序设计?答：多道程序设计是指在主存中同时存放多个程序，它们都处于执行的开始点和结束点之间，这些程序轮渡或以其他方式共享CPU。

多道程序设计的根本目的是提高CPU利用率和资源利用率，其体现的结果是并发。

操作系统中常用的进程调度算法1、先来先服务调度算法先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。

当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。

在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

2、短作业(进程)优先调度算法短作业(进程)优先调度算法，是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。

而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。

3、时间片轮转法在早期的时间片轮转法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。

时间片的大小从几ms到几百ms。

当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。

这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。

换言之，系统能在给定的时间内响应所有用户的请求。

4、多级反馈队列调度算法前面介绍的各种用作进程调度的算法都有一定的局限性。

如短进程优先的调度算法，仅照顾了短进程而忽略了长进程，而且如果并未指明进程的长度，则短进程优先和基于进程长度的抢占式调度算法都将无法使用。

而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间，而且还可以满足各种类型进程的需要，因而它是目前被公认的一种较好的进程调度算法。

#include<iostream>#define N 4#include <string>//时间片系列#include<stdio.h>#include<stdlib.h>#define MAX 4 //进程数量#define RR 4 //时间片大小//时间片系列using namespace std;struct time{string name;float arriveTime;float runTime;float finishTime;float totalTime;float weightTotalTime;};//时间片系列struct pro{char num;int arriveTime;int burst;int rt; //记录进程被运行的次数struct pro *next;};int TOTALTIME; //记录所有进程的总时间//时间片系列//函数声明struct pro* creatList();void insert(struct pro *head,struct pro *s);struct pro* searchByAT(struct pro *head,int AT);void del(struct pro* p);int getCount(struct pro *head,int time);struct pro* searchEnd(struct pro *head);void move(struct pro *headF,struct pro *headT,int n);struct pro* creatList() //创建链表，按照进程的到达时间排列,记录所有进程的信息{struct pro* head=(struct pro*)malloc(sizeof(struct pro));head->next=NULL;struct pro* s;int i;TOTALTIME=0;cout<<"输入进程名& 到达时间& 运行时间(example:a 0 0):"<<endl;cout<<"name "<<"arrivetime "<<"runtime"<<endl;for(i=0;i<MAX;i++){s=(struct pro*)malloc(sizeof(struct pro));cin>>s->num;cin>>s->arriveTime;cin>>s->burst;TOTALTIME+=s->burst; //计算总时间s->rt=1; //rt的初始值为1s->next=NULL;insert(head,s);}return head; //到达队列中的进程按照其到达时间的先后顺序排列}void insert(struct pro *head,struct pro *s) //插入节点{struct pro *p=searchByAT(head,s->arriveTime);s->next=p->next;p->next=s;return;}struct pro* searchByAT(struct pro *head,int AT) //查找第一个到达时间大于等于AT的节点，返回其前一个指针{struct pro *p,*q;p=head;q=head->next;while(q!=NULL&&q->arriveTime<=AT){p=q;q=q->next;}return p;}void del(struct pro* p) //删除p的下一个节点{struct pro *tmp;tmp=p->next;p->next=tmp->next;return;}int getCount(struct pro *head,int time) //察看在time之前到达但未移动到运行队列的进程数量{int count=0;struct pro *s,*t;s=head;t=s->next;while(t!=NULL&&t->arriveTime<=time){s=t;t=t->next;count++; //count记录当前时刻到达的进程数}return count;}struct pro* searchEnd(struct pro *head) //查找并返回循坏队列的尾节点的前一个节点{struct pro *p,*q;p=head;q=head->next;while(q->next!=head){p=q;q=q->next;}return p;}void move(struct pro *headF,struct pro *headT,int n) //将headF后的n个节点移动到循环队列headT中{struct pro *r,*s,*t;s=headF;t=s->next;r=t; //r记录要移动的第一个节点while(n>1){t=t->next;}s->next=t->next; //以上完成从原队列中摘除相关节点,r,t分别为第一个和最后一个节点s=searchEnd(headT);if(s!=headT)s=s->next;t->next=s->next;s->next=r;struct pro *f=s;}void run(struct pro *head){int time=0; //记录当前时间int newarrive;//新到达进程数struct pro *runhead=(struct pro*)malloc(sizeof(struct pro));runhead->next=runhead; //创建新的循环链表，存放当前就绪队列中的进程struct pro *p,*q;p=runhead;q=p->next; //q记录当前应当运行的进程while(time<=TOTALTIME){newarrive=getCount(head,time);if(newarrive>0)move(head,runhead,newarrive); //将head后的newarrive个节点移动到runhead队列中if(runhead->next==runhead) //就绪队列中没有进程time++;else if(q==runhead){p=q;q=q->next;}else{cout<<"进程名:"<<q->num<<endl;cout<<"到达时间:"<<q->arriveTime<<endl;if(q->rt==1)printf("响应时间:%d\n",time-q->arriveTime);elseprintf("第%d次运行开始时间:%d\n",q->rt,time);if(q->burst<=RR){time+=q->burst;printf("第%d次运行结束时间:%d\n",q->rt,time);printf("周转时间:%d\n",time-q->arriveTime);printf("************************************\n");struct pro *tmp=q;q=q->next;p->next=q;runhead->next=q;free(tmp);}else //q->burst>RR{time+=RR;printf("第%d次运行结束时间:%d\n",q->rt,time);printf("************************************\n");q->burst-=RR;q->rt++;struct pro *h;h=runhead->next;if(h->next!=runhead){while(h->next!=runhead)h=h->next;runhead->next=q->next;h->next=q;q->next=runhead;q=runhead->next;}else{ struct pro *n;n=q;p=q;q=q->next;}}}}}//时间片系列void InputTime(time *p){int i;//countercout<<"input name & arrive time & run time(example:a 00):"<<endl;cout<<"name "<<"arrivetime "<<"runtime"<<endl;for(i=0;i<=N-1;i++){float temp1,temp2;string name;cin>>name;p[i].name=name;cin>>temp1;p[i].arriveTime=temp1;cin>>temp2;p[i].runTime=temp2;}}void Print(time *p,float totalTimeSum,float weightTotalTimeSum){cout<<"********运行次序:"<<endl;for(int k=0;k<=N-1;k++){cout<<p[k].name<<" ";}cout<<endl;cout<<"平均周转时间:"<<totalTimeSum/N<<endl;cout<<"平均带权周转时间:"<<weightTotalTimeSum/N<<endl; }void sort(time *p){for(int i=0;i<=N-1;i++)for(int j=0;j<=i;j++)if(p[i].arriveTime<p[j].arriveTime){time temp;temp=p[i];p[i]=p[j];p[j]=temp;}}void deal(time *p,float &totalTimeSum,float&weightTotalTimeSum){int k;//counterfor(k=0;k<=N-1;k++){if(k==0)p[k].finishTime=p[k].arriveTime+p[k].runTime;elsep[k].finishTime=p[k-1].finishTime+p[k].runTime;}for(k=0;k<=N-1;k++){p[k].totalTime=p[k].finishTime-p[k].arriveTime;p[k].weightTotalTime=p[k].totalTime/p[k].runTime;totalTimeSum+=p[k].totalTime;weightTotalTimeSum+=p[k].weightTotalTime;}}void FCFS(time *p){float totalTimeSum=0,weightTotalTimeSum=0;sort(p);deal(p,totalTimeSum,weightTotalTimeSum);cout<<endl;cout<<"**********************"<<endl;cout<<"***先来先服务:"<<endl;Print(p,totalTimeSum,weightTotalTimeSum);cout<<"****************"<<endl;}void SWF(time *p){float totalTimeSum=0,weightTotalTimeSum=0;sort(p);for(int m=0;m<N-1;m++){if(m==0)p[m].finishTime=p[m].arriveTime+p[m].runTime;elsep[m].finishTime=p[m-1].finishTime+p[m].runTime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arriveTime<=p[m].finishTime)i++;}float min=p[m+1].runTime;int follow=m+1;for(int k=m+1;k<m+i;k++){if(p[k+1].runTime<min){min=p[k+1].runTime;follow=k+1;}}time temp;temp=p[m+1];p[m+1]=p[follow];p[follow]=temp;}deal(p,totalTimeSum,weightTotalTimeSum);cout<<endl;cout<<"**********************"<<endl;cout<<"***短作业优先:"<<endl;Print(p,totalTimeSum,weightTotalTimeSum);cout<<"**********************"<<endl;}void TRRF(time *p){float totalTimeSum=0,weightTotalTimeSum=0;sort(p);for(int m=0;m<N-1;m++){if(m==0)p[m].finishTime=p[m].arriveTime+p[m].runTime;elsep[m].finishTime=p[m-1].finishTime+p[m].runTime;int i=0;for(int n=m+1;n<=N-1;n++){if(p[n].arriveTime<=p[m].finishTime)i++;}float max=(p[m].finishTime-p[m+1].arriveTime)/p[m+1].runTime;int follow=m+1;for(int k=m+1;k<m+i;k++){if(max<=(p[m].finishTime-p[k+1].arriveTime)/p [k+1].runTime){max=(p[m].finishTime-p[k+1].arriveTime)/p[k+1].runTime;follow=k+1;}}time temp;temp=p[m+1];p[m+1]=p[follow];p[follow]=temp;}deal(p,totalTimeSum,weightTotalTimeSum);cout<<endl;cout<<"**********************"<<endl;cout<<"***最高响应比优先:"<<endl;Print(p,totalTimeSum,weightTotalTimeSum);cout<<"**********************"<<endl;}void main(){int lg;cout<<"请选择任一种算法："<<endl;cout<<"1.FCFS（先来先服务）2.SWF（短作业优先）3.TRRF（高响应比优先） 4.RR（时间片轮转）0.退出"<<endl;cin>>lg;cout<<endl;time a[N],b[N],c[N];while (lg){if(lg==1){InputTime(a);FCFS(a);cout<<endl;}//time *b=a;time *c=a;if(lg==2){InputTime(b);SWF(b);cout<<endl;}if(lg==3){InputTime(c);TRRF(c);cout<<endl;}//时间片系列if(lg==4){cout<<endl;cout<<"********时间片模拟*******"<<endl;struct pro *head=creatList();printf("当前时间片大小为:%d\n",RR);run(head);cout<<endl;}cout<<"1.FCFS（先来先服务）2.SWF（短作业优先）3.TRRF（高响应比优先） 4.RR（时间片轮转）0.退出"<<endl;cin>>lg;cout<<endl;}cout<<"您选择了退出模拟。

第一章1.操作系统设计目标：方便性、有效性、便于设计实现维护。

2.引入多道程序系统的原因：提高CPU的利用率。

特点：在主存同时存放多个作业，使之同时处于运行状态，共享系统中的各种资源。

3.操作系统基本功能：处理机管理、存储器管理、设备管理、文件管理。

4.批处理系统特点：吞吐量大、资源利用率高、无法交互、平均周转时间长。

分时系统特点：同时性、独立性、交互性、及时性。

实时系统特点：实时性、可靠性、确定性。

5.衡量OS的性能指标：资源利用率、吞吐量、周转时间。

6.对称多处理：操作系统和用户程序可安排在任何一个处理机上运行，各处理机共享主存和各种I/O设备。

7.操作系统的特性：并发性、共享性、虚拟性、异步性。

8.CPU工作状态：核心态（操作系统内核程序）、用户态（用户程序）。

用户态到核心态的转换由硬件完成。

核心态到用户态的转换由内核程序执行后完成。

9.系统调用：内核向用户提供的，用来运行系统内核子程序的接口。

特权指令执行时，CPU处于核心态。

10.用户与操作系统的接口：操作接口（命令语言或窗口界面）、编程接口（系统调用）。

第二、三章1.程序顺序执行的特点：串行性、封闭性、可再现性。

2.进程的四大特性：动态性、独立性、并发性、结构性。

3.进程控制块的组成部分：进程标识符、状态+调度+存储器管理信息、使用的资源信息、CPU现场保护区、记账信息、进程间家族关系、进程的链接指针。

4.进程基本状态：运行态、阻塞态、就绪态。

5.进程控制：是指系统使用一些具有特定功能的程序段来创建、撤消进程，以及完成进程各状态之间的转换。

6.进程调度的功能：记录系统中各进程的执行状况、选择就绪进程占有CPU、进行进程上下文的切换。

方式：非抢先/非剥夺方式（批处理）、抢先/剥夺方式（分时、实时）。

时机：①现行进程完成或错误终止；②提出I/O请求，等待I/O完成；③时间片用完或更高优先级进程就绪；④执行了某种原语操作。

7.进程调度的算法：先来先服务、最短作业优先、响应比高者优先、优先级调度法、轮转法、多级反馈队列轮转法。

编程进程或作业先来先服务高优先权按时间片轮转调度算法学生实验报告姓名：年级专业班级 10 级计算机3 班日期 201 2 年 12 月 9 日成绩课程名称计算机操作系统实验名称 2 编程进程或作业先来先服务、权、按时间片轮转调度算法（4 课时）实验类型验证设计综合创新【实验目的、要求】（1）通过编写程序实现进程或作业先来先服务、权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

（2）了解Windows2000/XP 中进程（线程）的调度机制。

（3）学习使用Windows2000/XP 中进程（线程）调度算法，掌握相应的与调度有关的Win32 API 函数。

【实验内容】在Windows XP、Windows 2000 等操作系统下，使用的VC、VB、java 或C 等编程语言，利用相应的WIN32 API 函数，编写程序实现进程或作业先来先服务、权、按时间片轮转调度算法。

【实验环境】（含主要设计设备、器材、软件等）一台计算机及c++软件【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）1、进程调度算法：采用多级反馈队列调度算法。

其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS 原则排队等待高度。

当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS 原则等待调度执行，以此类推。

2、实验步骤: （1）按先来先服务算法将进程排成就绪队列。

（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。

（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插入到下一个逻辑队列的队尾。

（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。

（5）重复步骤（2）、（3）、（4），直到就绪队列为空。

【计算机专业】操作系统先来先服务算法详解设计一个按先来先服务调度的算法提示：（1）假设系统中有5个进程，每个进程由一个进程控制块（PCB）来标识。

进程控制块内容如图1-1所示。

进程名即进程标识。

链接指针：按照进程到达系统的时间将处于就绪状态的进程连接成衣个就绪队列。

指针指出下一个到达进程的进程控制块首地址。

最后一个进程的链接指针为NULL。

估计运行时间：可由设计者任意指定一个时间值。

到达时间：进程创建时的系统时间或由用户指定。

调度时，总是选择到达时间最早的进程。

进程状态：为简单起见，这里假定进程有两种状态：就绪和完成。

并假定进程一创建就处于就绪状态，用R表示。

当一个进程运行结束时，就将其设置成完成态，用C表示。

（2）设置一个队首指针head，用来指出最先进入系统的进程。

各就绪进程通过链接指针连在一起。

（3）处理机调度时总是选择队首指针指向的进程投入运行。

由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而只是执行：估计运行时间减1。

用这个操作来模拟进程的一次运行，而且省去进程的现场保护和现场恢复工作。

（4）在所设计的程序中应有显示或打印语句，能显示或打印正运行进程的进程名、已运行时间、还剩时间、就绪队列中的进程等。

所有进程运行完成时，给出各进程的周转时间和平均周转时间。

/****************************************************************************** ************** 实验一先来先服务算法模拟程序* writen by daysky* 2007-11-19******************************************************************************** *************/#include <iostream>#include <list>#include <string>#include <fstream>using namespace std;//控制块结构体struct PCB{char name;//进程名PCB *next;//链接指针int reach_time;//到达时间int left_time;//估计运行时间int begin_time;char status;//R就绪c完成PCB();PCB(char aname,int areach_time,int aleft_time,int abegin_time=-1,char astatus='R',PCB *anext=NULL);PCB(const PCB &from);};PCB:CB(){next=NULL;reach_time = -1;left_time = -1;begin_time = -1;status = 'R';}PCB:CB(char aname,int areach_time,int aleft_time,int abegin_time,char astatus,PCB *anext){name = aname;reach_time = areach_time;left_time = aleft_time;begin_time = abegin_time;status = astatus;next = anext;}PCB:CB(const PCB &from){name = ;next = NULL;reach_time = from.reach_time;left_time = from.left_time;begin_time = -1;status = 'R';}/*** 先来先服务类**/class FirstServe{private:int systime;//系统时间list<CB *> *ready_list,*all_task;// 就绪队列所有任务int together_time;ofstream fout;public:FirstServe();FirstServe(list<CB *> *a_all_task,const char *logfile);bool run();void check_task();void run_ready();void print_ready();~FirstServe();};FirstServe::FirstServe(){systime=0;together_time = 0;ready_list=new list<CB *>();all_task=new list<CB *>();}FirstServe::FirstServe(list<CB *> *a_all_task,const char *logfile){systime=0;together_time = 0;ready_list = new list<CB *>();all_task = a_all_task;fout.open(logfile,ios::trunc);}//服务执行总调度bool FirstServe::run(){int num = all_task->size();while(ready_list->empty()){//添加新进程,同时从所有队列中删除刚添加的进程check_task();systime++;//运行直到有任务}do{//打印就绪队列print_ready();//执行就绪队列run_ready();systime++;check_task();}while(!ready_list->empty());//打印平均周转时间fout << "平均周转时间为:" << together_time/num << "!" << endl; return true;}//检查到达的任务，添加到就绪队列的尾部void FirstServe::check_task(){PCB *current;list<CB *>::iterator it;it = all_task->begin();//这里用循环处理，因为可能有多个同时到达的任务while(it!=all_task->end()){current=(*it);if(current->reach_time==systime){PCB *a_pcb = new PCB(*current);//复制进程信息a_pcb->status = 'R';ready_list->push_back(a_pcb);//添加在就绪队列的尾部it = all_task->erase(it); //从所有任务中删除这个任务fout << "进程" << a_pcb->name << "在时刻:" << systime << "进入就绪队列!" << endl;}elseit++;}}//执行就绪队列，运行队列的第一个进程void FirstServe::run_ready(){if(ready_list->empty()) return;//就绪队列为空就不执行,否则PCB *front = ready_list->front();if(front->begin_time == -1)//进程第一次运行，设置运行起始时间front->begin_time = systime;front->left_time --;//执行一次，估计时间减一fout << "进程" << front->name << "执行在时刻:" << systime << "!" << endl;fout << "进程" << front->name << "已运行时间:" << (systime-front->begin_time+1)<< "!" << endl;fout << "进程" << front->name << "还剩时间为:" << front->left_time << "!" << endl;//当进程完成，改变进程的状态if(front->left_time == 0){front->status = 'C';//打印并计算周转时间,systime-1为完成时间fout << "进程" << front->name << "在时刻:" << systime << "结束!" << endl;int a_time = systime-1-front->reach_time;together_time += a_time;fout << "进程" << front->name << "的周转时间为:" << a_time << "!" <<endl;ready_list->pop_front();//删除第一个元素}}void FirstServe::print_ready(){fout << "就绪队列中的进程有：";list<CB *>::iterator it=ready_list->begin();while(it!=ready_list->end()){fout << (*it)->name << "、";it++;}fout << endl;}FirstServe::~FirstServe(){fout.close();}int main(){PCB *a_pcb[5];list<CB *> *all_task=new list<CB *>();cout << "正在初始化........" << endl;//五个进程的到达时间各不相同a_pcb[0] = new PCB('A',9,10);a_pcb[1] = new PCB('B',1,30);a_pcb[2] = new PCB('C',3,25);a_pcb[3] = new PCB('D',5,40);a_pcb[4] = new PCB('E',2,33);for(int i=0;i<5;i++){all_task->push_back(a_pcb);}FirstServe fs(all_task,"fcfs_log.txt");cout << "正在执行........" << endl;fs.run();cout << "执行完毕！" << endl;return 0;}。

操作系统编程进程或作业先来先服务、高优先权、按时间片轮转调度算法湖南农业大学科学技术师范学院学生实验报告姓名: 汤黎波年级专业班级 06级计算机教育班日期 2008 年 12 月 8 日成绩验证设计编程进程或作业先来先服务、综合创新实验类型课程名称计算机操作系统实验名称高优先权、按时间片轮转调度算法(4学时)【实验目的、要求】实验目的:(1)通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。

(2)了解Windows2000/XP中进程(线程)的调度机制。

(3)学习使用Windows2000/XP中进程(线程)调度算法，掌握相应的与调度有关的Win32 API函数。

实验要求:(1)经调试后程序能够正常运行。

(2)采用多进程或多线程方式运行，体现了进程或作业先来先服务、高优先权、按时间片轮转调度的关系。

(3)程序界面美观。

【实验内容】在Windows XP、Windows 2000等操作系统下，使用C语言，利用相应的WIN32 API函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。

【实验环境】(含主要设计设备、器材、软件等)Pc电脑一台【实验步骤、过程】(含原理图、流程图、关键代码，或实验过程中的记录、数据等)定义:1)先来先服务算法:如果早就绪的进程排在就绪队列的前面，迟就绪的进程排在就绪队列的后面，那么先来先服务(FCFS:first come first service)总是把当前处于就绪队列之首的那个进程调度到运行状态。

2)轮转法就是按一定时间片(记为q)轮番运行各个进程。

如果q是一个定值，则轮转法是一种对各进程机会均等的调度方法。

3)优先级调度的基本思想是，把当前处于就绪队列中优先级最高的进程投入运行，而不管各进程的下一个CPU周期的长短和其他因素。

实验步骤: (1)需求分析:了解基本原理，确定程序的基本功能，查找相关资料，画出基本的数据流图;(2)概要设计:确定程序的总体结构、模块关系和总体流程;(3)详细设计:确定模块内部的流程和实现算法;(4)上机编码和调试;(5)运行测试;(6)编写实验报告。