操作系统实验二进程调度
操作系统实验报告进程调度
五邑大学实验报告操作系统课程2016~2017年度第1学期实验题目：进程调度院系：计算机学院班级： 140801学号： 3114002472姓名：黄凯鑫任课教师：白明成绩评定：实验二题目：进程调度完成日期：2016年12 月11 日1、实验目的（1）设计一个有n个进程工行的进程调度程序。
每个进程由一个进程控制块（PCB）表示。
进程控制块通常应包含下述信息：进程名、进程优先数、进程需要运行的时间、占用CPU的时间以及进程的状态等，且可按调度算法的不同而增删。
（2）调度程序应包含2～3种不同的调度算法，运行时可任意选一种，以利于各种算法的分析比较。
（3）系统应能显示或打印各进程状态和参数的变化情况，便于观察诸进程的调度过程2、实验内容（1）编制和调试示例给出的进程调度程序，并使其投入运行。
（2）自行设计或改写一个进程调度程序，在相应机器上调试和运行该程序，其功能应该不亚于示例。
（3）直观地评测各种调度算法的性能。
3、算法设计算法：(1) 优先数法。
进程就绪链按优先数大小从高到低排列，链首进程首先投入运行。
每过一个时间片，运行进程所需运行的时间片数减1，说明它已运行了一个时间片，优先数也减3，理由是该进程如果在一个时间片中完成不了，优先级应该降低一级。
接着比较现行进程和就绪链链首进程的优先数，如果仍是现行进程高或者相同，就让现行进程继续进行，否则，调度就绪链链首进程投入运行。
原运行进程再按其优先数大小插入就绪链，且改变它们对应的进程状态，直至所有进程都运行完各自的时间片数。
(2) 简单轮转法。
进程就绪链按各进程进入的先后次序排列，进程每次占用处理机的轮转时间按其重要程度登入进程控制块中的轮转时间片数记录项（相当于优先数法的优先数记录项位置）。
每过一个时间片，运行进程占用处理机的时间片数加1，然后比较占用处理机的时间片数是否与该进程的轮转时间片数相等，若相等说明已到达轮转时间，应将现运行进程排到就绪链末尾，调度链首进程占用处理机，且改变它们的进程状态，直至所有进程完成各自的时间片。
操作系统实验-进程调度2
//状态宏
#defineWAIT 0x01
#defineRUN 0x02
#defineFINISH 0x03
#defineID_ERROR 0x10
#defineMIN_PRIOR 0xFF
#defineMAX_PRIOR 0x00
//自定义数据类型
{
if(g_queue[i].s_state!=FINISH)
{
temp_prior = g_queue[i].s_dynamic_prior * 100 + g_queue[i].s_static_prior;
if(temp_prior <= prior)
{
id = i;
prior = temp_prior;
{
Work_Process(id);
}
}
Uint32 Get_PriProceபைடு நூலகம்s()
{
Uint32 id = ID_ERROR;
inti,prev_id = ID_ERROR;
Uint32 prior = MIN_PRIOR * 2, temp_prior;
for(i=0;i<PRO_NUM;++i)
{
inti =0;
Uint32 id = ID_ERROR;
for(i = 0;i<PRO_NUM;++i)
{
if(g_queue[i].s_state==FINISH)
{
id = g_queue[i].s_id;
g_queue[i].s_dynamic_prior = 0;
g_queue[i].s_need_time =needtime;
操作系统实验报告(进程调度)
华中师范大学计算机科学系《操作系统》实验报告实验题目：进程调度学生姓名：日期：2011-12-9实验2进程调度进程完成，撤消该进程就绪队列首进程投入运行 时间片到，运行进程已占用CPU 时间+1 运行进程已占用CPU 时间已达到所需的运行时间 把运行进程插入到下一个队列的队尾插入新的进程开始 初始化PCB,输入进程信息 所有队列都为空 各进程按FCFS 原则排队等待调度 【实验目的】（1）通过编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法，使学生进一步掌握进程调度的概念和算法，加深对处理机分配的理解。
（2）了解Windows2000/XP 中进程（线程）的调度机制。
（3）学习使用Windows2000/XP 中进程（线程）调度算法，掌握相应的与调度有关的Win32 API 函数。
【实验内容】在Windows XP 、Windows 2000等操作系统下，使用的VC 、VB 、java 或C 等编程语言，利用相应的WIN32 API 函数，编写程序实现进程或作业先来先服务、高优先权、按时间片轮转调度算法。
【实验步骤、过程】（含原理图、流程图、关键代码，或实验过程中的记录、数据等）1、进程调度算法：采用多级反馈队列调度算法。
其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS 原则排队等待高度。
当轮到该进程执行时，如能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚为完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS 原则等待调度执行，以此类推。
2、实验步骤:（1）按先来先服务算法将进程排成就绪队列。
（2）检查所有队列是否为空，若空则退出，否则将队首进程调入执行。
（3）检查该运行进程是否运行完毕，若运行完毕，则撤消进程，否则，将该进程插入到下一个逻辑队列的队尾。
（4）是否再插入新的进程,若是则把它放到第一逻辑队列的列尾。
（5）重复步骤（2）、（3）、（4），直到就绪队列为空。
操作系统实验报告进程调度
操作系统实验报告进程调度操作系统实验报告：进程调度引言操作系统是计算机系统中最核心的软件之一，它负责管理和调度计算机的资源，提供良好的用户体验。
在操作系统中，进程调度是其中一个重要的功能，它决定了进程的执行顺序和时间片分配，对于提高计算机系统的效率和响应能力至关重要。
本篇实验报告将重点介绍进程调度的相关概念、算法和实验结果。
一、进程调度的概念进程调度是操作系统中的一个重要组成部分，它负责决定哪个进程可以使用CPU，并为其分配执行时间。
进程调度的目标是提高系统的吞吐量、响应时间和公平性。
在多道程序设计环境下，进程调度需要考虑多个进程之间的竞争和协作，以实现资源的合理利用。
二、进程调度算法1. 先来先服务调度（FCFS）先来先服务调度算法是最简单的进程调度算法之一，它按照进程到达的顺序进行调度，即先到达的进程先执行。
这种算法的优点是公平性高，缺点是无法适应长作业和短作业混合的情况，容易产生"饥饿"现象。
2. 最短作业优先调度（SJF）最短作业优先调度算法是根据进程的执行时间来进行调度的，即执行时间最短的进程先执行。
这种算法的优点是能够最大程度地减少平均等待时间，缺点是无法适应实时系统和长作业的情况。
3. 时间片轮转调度（RR）时间片轮转调度算法是一种抢占式调度算法，它将CPU的执行时间划分为固定大小的时间片，并按照轮转的方式分配给各个进程。
当一个进程的时间片用完后，它将被挂起，等待下一次调度。
这种算法的优点是能够保证每个进程都能够获得一定的执行时间，缺点是无法适应长作业和短作业混合的情况。
4. 优先级调度（Priority Scheduling）优先级调度算法是根据进程的优先级来进行调度的，优先级高的进程先执行。
这种算法的优点是能够根据进程的重要性和紧急程度进行灵活调度，缺点是可能会导致低优先级的进程长时间等待。
三、实验结果与分析在实验中，我们使用了不同的进程调度算法，并对其进行了性能测试。
操作系统实验二报告-时间片轮转进程调度算法1
操作系统实验报告实验二时间片轮转进程调度算法学号：班级：姓名:【实验题目】: 时间片轮转进程调度算法【实验目的】通过这次实验, 加深对进程概念的理解, 进一步掌握进程状态的转变、进程调度的策略与对系统性能的评价方法。
【实验内容】问题描述:设计程序模拟进程的时间片轮转RR 调度过程。
假设有n 个进程分别在T1, … ,Tn 时刻到达系统, 它们需要的服务时间分别为S1, … ,Sn 。
分别利用不同的时间片大小q, 采用时间片轮转RR 进程调度算法进行调度, 计算每个进程的完成时间, 周转时间和带权周转时间, 并且统计n 个进程的平均周转时间和平均带权周转时间。
程序要求如下:1）进程个数n ；每个进程的到达时间T 1, … ,T n 和服务时间S 1, … ,S n ；输入时间片大小q 。
2）要求时间片轮转法RR 调度进程运行, 计算每个进程的周转时间, 带权周转时间, 并且计算所有进程的平均周转时间, 带权平均周转时间；3）输出: 要求模拟整个调度过程, 输出每个时刻的进程运行状态, 如“时刻3: 进程B开始运行”等等；4）输出：要求输出计算出来的每个进程的周转时间, 带权周转时间, 所有进程的平均周转时间, 带权平均周转时间。
实现提示:用C++语言实现提示:1）程序中进程调度时间变量描述如下:int ArrivalTime[100];int ServiceTime[100];int PServiceTime[100];int FinishTime[100];int WholeTime[100];double WeightWholeTime[100];double AverageWT,AverageWWT;bool Finished[100];➢2）进程调度的实现过程如下:➢变量初始化；➢接收用户输入n, T1, … ,Tn, S1, … ,Sn；时间片大小q；➢按照时间片轮转RR算法进行进程调度, 计算进程的完成时间、周转时间和带权周转时间；➢计算所有进程的平均周转时间和平均带权周转时间；➢按格式输出调度结果。
操作系统实验进程调度
实验二进程调度⒈实验内容进程调度模拟实验。
⒉实验目的通过模拟进程调度算法，了解进程调度的过程并比较不同的调度算法的区别。
⒊实验题目设计一段程序来模拟优先级调度算法和时间片轮转算法。
要求可以指定进程的数量、各进程需要CPU的时间和各进程的优先级。
⒋实验提示⑴进程调度算法是指处理机的分配策略。
优先数调度算法是指对每个进程确定一个优先数，进程调度总是让具有最高优先数的进程先使用处理机。
如果进程具有相同的优先数，再按先来先服务的次序分配处理机。
在本实例中采用动态优先数算法。
时间片轮转算法是指就绪进程按就绪的先后次序排成队列，每次总是选择就绪队列中的第一个进程占用处理机，但规定只能使用一个“时间片”。
⑵系统中的进程可以用进程控制块PCB来表示，PCB的结构定义如表5-8所示：表5-8 PCB结构⑶在进程调度时进程会交替的出现在运行、就绪和完成三种状态。
可以定义三个链表来存放三种状态的进程。
当进程运行时就把进程放入到运行链表中；当进程处于就绪状态时就将进程放入到就绪链表中；当进程运行完毕时就将进程放入到完成链表中。
由于同一时刻运行的进程只能有一个，所以运行链表只能有一个结点。
在实例程序中为了使程序更简洁忽略了进程的等待状态，仅运行了优先数调度算法，由于篇幅有限，仅显示部分结果，对于时间片轮转调度算法，请读者自行运行。
⑷主要变量及函数说明如表5-9所示：表5-9 主要变量及函数说明⒌实例代码//进程调度算法proc.c//运行环境Redhad9.0 gcc 4.0#include <stdio.h>#include <string.h>typedef struct pcb //定义PCB结构{char name[20]; /*进程标识符*/int cputime; /*进程占用CPU时间*/int prio; /*进程优先数*/int needtime; /*进程到完成还需要的CPU时间*/struct pcb *next;/*链指针*/}PCB;PCB *RUN,*READY,*RTAIL,*FINSH,*FTAIL;void PRINTLINK(int t)/*输出3个队列*/{PCB *p;printf("CPU运行次数:___%d___\n",t);printf("______________________\n");printf("进程名\t运行状态\t运行次数\t还需要运行次数\n");if(RUN!=NULL){printf("%s\t运行\t%d\t%d\n",RUN->name,RUN->cputime,RUN->needtime);}elseprintf("*运行状态为空\n");p=READY;if(p!=NULL){while(p!=NULL){printf("%s\t就绪\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*就绪队列为空\n");p=FINSH;if (p!=NULL){while(p!=NULL){//printf(" 进程名字为:%s\n",p->name);printf("%s\t完成\t%d\t%d\n",p->name,p->cputime,p->needtime);p=p->next;}}elseprintf("*完成队列为空\n");getchar();}PCB *CPCBLINK()/*建立就绪队列*/{printf("建立就绪队列\n\n");int i,n,nt,pr;PCB *p,*q,*head;n=0;while(1){printf("请输入进程的个数(有效范围1-100)：");scanf("%d",&n);printf("\n");if (n>=1&&n<=100)break;elseprintf("输入有误。
实验二--单处理器系统的进程调度
实验二–单处理器系统的进程调度
简介
在操作系统中，进程调度是非常重要的一项工作。
进程调度负责将CPU分配
给各个进程，使得每个进程都能够有机会占用CPU资源。
在单处理器系统中，CPU只有一个，因此进程调度是非常重要的。
本次实验将会探究单处理器系统的进程调度，了解各种进程调度算法的实现和
比较，利用模拟操作系统的实验平台进行实验。
实验目的
1.了解进程调度的基本概念和实现方法；
2.学习多种进程调度算法，并比较其优缺点；
3.熟悉模拟操作系统的实验环境，学习如何将算法实现到具体的系统中。
实验内容
进程调度的基本概念
进程调度是指将CPU资源分配给各个进程的过程。
在单处理器系统中，当有
多个进程需要使用CPU时，操作系统需要进行进程调度，使得每个进程都能够得
到CPU资源。
在进程调度中，需要考虑各个进程的优先级、进程的状态和进程的等待时间等
因素。
根据不同的调度算法，可以根据这些因素来确定哪个进程应该先占用CPU。
进程调度算法比较
常见的进程调度算法包括：
1.先来先服务算法（FCFS）
2.短作业优先算法（SJF）
3.优先级调度算法
4.时间片轮转算法（RR）
下面将对这些算法进行比较和介绍。
先来先服务算法（FCFS）
先来先服务算法是最简单的一种进程调度算法。
该算法将按照进程的到达时间
的先后顺序进行调度，先到达的进程先得到CPU资源。
这种算法的优点是实现简单，适用于短作业和计算密集型进程。
缺点是无法充分利用CPU资源，导致长作业需要等待较长时间才能被调度，容易产生。
操作系统实验二并发与调度
实验二并发与调度一、实验目的在本实验中，通过对事件和互斥体对象的了解，来加深对Windows 2000线程同步的理解。
通过分析实验程序，了解管理事件对象的API。
了解在进程中如何使用事件对象，在进程中如何使用互斥体对象，线程如何通过文件映射对象发送数据。
二、实验环境硬件环境：计算机一台，局域网环境；软件环境：Windows 2000 Professional，Visual C++ 6.0专业版或企业版。
三、实验内容和步骤第一部分：互斥体对象本程序中显示的类CCountUpDown使用了一个互斥体来保证对两个线程间单一数值的访问。
每个线程都企图获得控制权来改变该数值，然后将该数值写入输出流中。
创建者实际上创建的是互斥体对象，计数方法执行等待并释放，为的是共同使用互斥体所需的资源(因而也就是共享资源) 。
1、利用互斥体保护共享资源程序参见实验指导书分析程序的运行结果，可以看到线程(加和减线程) 的交替执行(因为Sleep() API允许Windows切换线程) 。
在每次运行之后，数值应该返回初始值(0) ，因为在每次运行之后写入线程在等待队列中变成最后一个，内核保证它在其他线程工作时不会再运行。
1)请描述运行结果(如果运行不成功，则可能的原因是什么？) ：2) 根据运行输出结果，对照分析程序，可以看出程序运行的流程吗？请简单描述：_____逆向运行__________第二部分线程通过文件对象发送数据Windows 2000提供的线程间通讯类内核对象允许同一进程或跨进程的线程之间互相发送信息，包括文件、文件映射、邮件位和命名管道等，其中最常用的是文件和文件映射。
这类对象允许一个线程很容易地向同一进程或其他进程中的另一线程发送信息。
1、演示线程通过文件对象发送数据程序参见实验指导书运行结果(如果运行不成功，则可能的原因是什么？) ：阅读和分析程序，请回答问题：1) 程序中启动了多少个单独的读写线程？__________100__________________________________________________________2) 使用了哪个系统API函数来创建线程例程？_________ CreateThread（）________________________________3) 文件的读和写操作分别使用了哪个API函数？_______ ReadFile（）______ WriteFile（）_____________ 每次运行进程时，都可看到程序中的每个线程从前面的线程中读取数据并将数据增加，文件中的数值连续增加。
操作系统实验二进程调度
实验二：进程调度一、目的要求：用C或C++语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解．二、进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。
进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用已占用CPU时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
三调度算法的流程图如下 :四、程序代码：#include<iostream>using namespace std;#define MAX 10struct task_struct{char name[10]; /*进程名称*/ int number; /*进程编号*/ float come_time; /*到达时间*/float run_begin_time; /*开始运行时间*/ float run_time; /*运行时间*/float run_end_time; /*运行结束时间*/ int priority; /*优先级*/int order; /*运行次序*/int run_flag; /*调度标志*/}tasks[MAX];int counter; /*实际进程个数*/int fcfs(); /*先来先服务*/int ps(); /*优先级调度*/int sjf(); /*短作业优先*/int hrrn(); /*响应比高优先*/int pinput(); /*进程参数输入*/int poutput(); /*调度结果输出*/void main(){int option;pinput();printf("请选择调度算法（0~4）:\n");printf("1.先来先服务\n");printf("2.优先级调度\n");printf(" 3.短作业优先\n");printf(" 4.响应比高优先\n");printf(" 0.退出\n");scanf("%d",&option);switch (option){ case 0:printf("运行结束。
进程调度算法实验报告
计算机操作系统实验报告实验二进程调度算法一、实验名称：进程调度算法二、实验内容：编程实现如下算法：1.先来先服务算法；2.短进程优先算法；3.时间片轮转调度算法。
三、问题分析与设计：1.先来先服务调度算法先来先服务调度算法是一种最简单的调度算法，该算法既可以用于作业调度，也可用于进程调度。
当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将他们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。
该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
FCFS算法比较有利于长作业（进程），2.短作业（进程）优先调度算法短作业（进程）优先调度算法SJ（P）F，是指对短作业或短进程优先调度的算法。
它们可以分别用于作业调度和进程调度。
短作业优先（SJF）的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。
而短进程（SPF）调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机再重新调度。
SJ(P)F调度算法能有效地降低作业（进程）的平均等待时间，提高系统吞吐量。
该算法对长作业不利，完全未考虑作业的紧迫程度。
3.时间片轮转算法在时间片轮转算法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
当执行的时间片用完时，由一个计数器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。
换言之，系统能在给定的时间内响应所有用户的请求。
实验二 进程调度 实验报告
（1）输入进程数、进程名、要求运行时间、已运行时间以及进程状态，初
始状态都为“就绪”，用“R”表示。当一个进程运行结束后，它的状态为“结束”，用“E”表示。
（2）把所有进程按顺序排成循环队列，用指针进行连接。
（3）运行队列中的队首进程，执行一个时间片，同时将该进程的“已运行
时间”+1，同时判断“要求运行时间”和“已运行时间”是否相等，如果相等，则将该进程状态修改为“E”，并退出循环队列，指针指向下一个进程；若不相等，则指针直接指向下一个进程，执行下一个时间片。
3.流程图
五、实验结果和分析（运行结果截图）
问题一
问题二
2.问题二
本题采用的是动态改变响应比的办法。首先根据公式
计算每个进程的响应比即优先数，根据响应比的大小降序排列，响应比大
的进程优先得到服务,每次执行一个时间片。由于本实验是模拟操作系统调
度进程的过程，被选中的进程并不实际的启动运行，而是执行： 要求运行
时间-1、等待时间为0，其它进程等待时间+1。进入下一轮运行时进程重
实验目的如下：
1.利用高级语言模拟进程的时间片轮转调度算法，并熟练掌握。
2.利用高级语言模拟进程的响应比高者优先调度算法，并熟练掌握。
二、实验原理
1.问题一
针对系统的所有进程，首先确定所有进程的要求运行时间（已运行时间初始值为0）；将所有进程按顺序排成循环队列，用指针指出队列连接情况，同时另用一个标志单元记录轮到运行的进程，此时以轮转法进行调度；先将CPU分配给队首进程，并令其执行一个时间片，当它运行完毕后，将CPU分配给就绪队列中新的队首进程，让其执行一个时间片，进程每被调度一次，该进程已运行时间+1，同时，判断该进程的要求运行时间与已运行时间，若该进程的要求运行时间已运行时间，则表示它尚未执行结束，应待到下一轮时再运行，若该进程的要求运行时间=已运行时间，则表示它已经执行结束，应指导它的状态修改成“结束”，并退出队列。此时，把该进程的进程控制块中的指针值送到前面一个进程的指针位置，直到所有的进程都成为“结束”状态。
Linux操作系统实验2-进程调度的操作
1.查看并创建用户的计划任务列表crontab文件；
1)查看crontab命令的帮助信息；
在终端下键入info crontab, 进入crontab帮助手册：
2)查看用户的计划任务列表；
查看特定用户的计划任务列表：
在终端下键入crontab -l -u duke 列出duke用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
查看当前用户的计划任务列表：
在终端下键入crontab -l 列出当前用户的所有定时任务，如下：
终端提示no crontab for duke，说明用户duke目前没有计划任务。
2.通过crontab文件对调度进程的计划任务进行编排操作。
1)建立crontab文件；
在终端下键入crontab -e ，提示当前无crontab文件，选择编辑器并新建如下：进入VI编辑器，编辑当前crontab文件，可以看到提供了一些注解作说明。
在crontab中输入0 3 * * 1 ls /etc 并保存，实现在每周一早上三点执行ls /etc 命令。
再次查看crontab文件，可以看到已经保存。
2)使用crontab命令安装crontab文件，安排计划任务；
对于位于/home下的crontab文件，使用crontab <filename>载入crontab计划任务中，如图：
3)查看计划任务表，确认计划任务是否已被安排；
键入crontab -l，查看计划任务安排情况，如图：
4)删除计划任务列表。
在终端下键入crontab -r ，删除当前用户的crontab文件，如下：。
实验二：进程调度
实验二 进程调度一、 实验目的多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那个进程优先占有处理机。
因而引起进程调度。
本实验模拟在单处理机情况下的处理机调度问题，加深对进程调度的理解。
二、 实验要求1． 设计进程调度算法，进程数不定2． 包含几种调度算法，并加以实现3． 输出进程的调度过程——进程的状态、链表等。
三、 参考例1．题目——优先权法、轮转法简化假设1） 进程为计算型的（无I/O ）2） 进程状态：ready 、running 、finish3） 进程需要的CPU 时间以时间片为单位确定2．算法描述1） 优先权法——动态优先权当前运行进程用完时间片后，其优先权减去一个常数。
2） 轮转法四、 实验流程图 开始 键盘输入进程数n ，和调度方法的选择 优先权法？ 轮转法产生n 个进程，对每个进程产生一个PCB ，并用随机数产生进程的优先权及进程所需的CPU 时间按优先权大小，把n 个进程拉成一个就绪队列撤销进程就绪队列为空？结束 N YY注意：1．产生的各种随机数的取值范围加以限制，如所需的CPU 时间限制在1~20之间。
2．进程数n 不要太大通常取4~8个3．使用动态数据结构4．独立编程5．至少三种调度算法6．若有可能请在图形方式下，将PCB 的调度用图形成动画显示。
五．实验过程：要求：读懂下面给出的程序，然后将其改写成由用户选择调度方式，例如：1、 FIFO2、 优先权调度3、 时间片轮转4、 退出对于每一种调度算法，由用户确定进程数，数据可以从文件读取，也可由用户手动输入。
（1）输入：进程流文件（1.txt ），其中存储的是一系列要执行的进程， 每个作业包括四个数据项：进程名 进程状态(1就绪 2等待 3运行) 所需时间 优先数(0级最高)进程0 1 50 2进程1 2 10 4进程2 1 15 0进程3 3 28 5进程4 2 19 1 产生n需的时间片数，已占用CPU 的时间片数置为0按进程产生的先后次序拉成就绪队列链=0？ 撤销该进程就绪队列为空吗？ =轮转时间片数？NY YY 结束 N进程5 3 8 7输出: 进程执行流等待时间，平均等待时间本程序包括:FIFO算法，优先数调度算法，时间片轮转调度算法（2）程序代码#include<stdio.h>#include<string.h>#include<iostream.h>const int block_time=10; //定义时间片的长度为10秒const int MAXPCB=100; //定义最大进程数//定义进程结构体typedef struct node{char name[20];int status;int time;int privilege;int finished;int wait_time;}pcb;pcb pcbs[MAXPCB];int quantity;//初始化函数void initial(){int i;for(i=0;i<MAXPCB;i++){strcpy(pcbs[i].name,"");pcbs[i].status=0;pcbs[i].time=0;pcbs[i].privilege=0;pcbs[i].finished=0;pcbs[i].wait_time=0;}quantity=0;}//读数据函数int readData(){FILE *fp;char fname[20];int i;cout<<"请输入进程流文件名:";cin>>fname;if((fp=fopen(fname,"r"))==NULL){cout<<"错误,文件打不开,请检查文件名"<<endl;}else{while(!feof(fp)){fscanf(fp,"%s %d %d %d",pcbs[quantity].name,&pcbs[quantity].status,&pcbs[quantity].time,&pcbs[quantity].privilege);quantity++;} //输出所读入的数据cout<<"输出所读入的数据"<<endl;cout<<"进程名进程状态所需时间优先数"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" \t"<<pcbs[i].status<<" \t"<<pcbs[i].time<<" \t"<<pcbs[i].privilege<<endl;}return(1);}return(0);}//重置数据,以供另一个算法使用void init(){int i;for(i=0;i<MAXPCB;i++){pcbs[i].finished=0;pcbs[i].wait_time=0;}}//先进先出算法void FIFO(){int i,j; int total;//输出FIFO算法执行流cout<<endl<<"*****************************************************"<<endl;cout<<"FIFO算法执行流:"<<endl; cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[i].name<<" "<<pcbs[i].wait_time<<endl;for(j=i+1;j<quantity;j++){pcbs[j].wait_time+=pcbs[i].time;}}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl;}//优先数调度算法void privilege(){int i,j,p;int passed_time=0;int total;int queue[MAXPCB];int current_privilege=1000;for(i=0;i<quantity;i++){current_privilege=1000;for(j=0;j<quantity;j++){if((pcbs[j].finished==0)&&(pcbs[j].privilege<current_privilege)){p=j;current_privilege=pcbs[j].privilege;}}queue[i]=p;pcbs[p].finished=1;pcbs[p].wait_time+=passed_time;passed_time+=pcbs[p].time;}//输出优先数调度执行流cout<<endl<<"***********************************************************"<< endl;cout<<"优先数调度执行流:"<<endl;cout<<"进程名等待时间"<<endl;for(i=0;i<quantity;i++){cout<<" "<<pcbs[queue[i]].name<<" "<<pcbs[queue[i]].wait_time<<endl;}total=0;for(i=0;i<quantity;i++){total+=pcbs[i].wait_time;}cout<<"总等待时间:"<<total<<" 平均等待时间:"<<total/quantity<<endl; }//时间片轮转调度算法void timer(){int i,j,number,flag=1;int passed_time=0;int max_time=0;int round=0;int queue[1000];int total=0;while(flag==1){flag=0;number=0;for(i=0;i<quantity;i++){if(pcbs[i].finished==0){number++; j=i;}}if(number==1){queue[total]=j;total++;pcbs[j].finished=1;}if(number>1){for(i=0;i<quantity;i++){if(pcbs[i].finished==0){flag=1;queue[total]=i;total++;if(pcbs[i].time<=block_time*(round+1)){pcbs[i].finished=1;}}}}round++;}if(queue[total-1]==queue[total-2]){total--;}cout<<endl<<"*******************************************************"<<endl;cout<<"时间片轮转调度执行流:"<<endl;for(i=0;i<total;i++){cout<<pcbs[queue[i]].name<<" ";cout<<endl;}}//显示void version(){cout<<" /********************* 进程调度********************/";cout<<endl<<endl;}//主函数void main(){int flag;version();initial();flag=readData();if(flag==1){FIFO();init();privilege();init();timer();}}（3）运行结果：输入进程流文件名1.txt即可得出以下输出结果：。
操作系统进程调度实验报告
学生实验报告姓名：年级专业班级学号成绩
【实验结果或总结】（对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意
1.三种进程调度算法的执行结果如下。
(1)FCFS算法
(2)高优先权优先调度算法
(3)时间片轮转调度算法
2.以上三个程序能较好地实现进程的三种调度算法。
(1)用数组元素的顺序输入输出能实现进程的FCFS算法。
(2)用优先权的变化规律描述和冒泡法排序能模拟实现优先权调度算法。
(3)通过数组的运算和利用中间数组能实现时间片轮转调度算法。
3. 虽然以上三个程序能较直观的体现进程基本的三种调度算法，但还是存在一些不足。
(1)如在高优先权调度算中，当同时出现多个进程优先权相同的情况时，程序可能对这些不能选择正确的执行顺序。
改进的方法为添加一个判断，当多个进程的优先权相同时，按FCFS算法执行。
即在程序中表现为按数组元素下标的增大顺序排序。
(2)在时间片轮转算法中，不能一次性的输出进程的调度程度，而要通过多次的输入时间片。
改进的方法为把时间片设置为全局变量，在每次循环时都执行一次。
指导教师签名：
20 年月日
【备注。
《操作系统》实验二
《操作系统》实验二一、实验目的本实验旨在加深对操作系统基本概念和原理的理解，通过实际操作，提高对操作系统设计和实现的认知。
通过实验二，我们将重点掌握进程管理、线程调度、内存管理和文件系统的基本原理和实现方法。
二、实验内容1、进程管理a.实现进程创建、撤销、阻塞、唤醒等基本操作。
b.设计一个简单的进程调度算法，如轮转法或优先级调度法。
c.实现进程间的通信机制，如共享内存或消息队列。
2、线程调度a.实现线程的创建、撤销和调度。
b.实现一个简单的线程调度算法，如协同多任务（cooperative multitasking）。
3、内存管理a.设计一个简单的分页内存管理系统。
b.实现内存的分配和回收。
c.实现一个简单的内存保护机制。
4、文件系统a.设计一个简单的文件系统，包括文件的创建、读取、写入和删除。
b.实现文件的存储和检索。
c.实现文件的备份和恢复。
三、实验步骤1、进程管理a.首先，设计一个进程类，包含进程的基本属性（如进程ID、状态、优先级等）和操作方法（如创建、撤销、阻塞、唤醒等）。
b.然后，实现一个进程调度器，根据不同的调度算法对进程进行调度。
可以使用模拟的方法，不需要真实的硬件环境。
c.最后，实现进程间的通信机制，可以通过模拟共享内存或消息队列来实现。
2、线程调度a.首先，设计一个线程类，包含线程的基本属性（如线程ID、状态等）和操作方法（如创建、撤销等）。
b.然后，实现一个线程调度器，根据不同的调度算法对线程进行调度。
同样可以使用模拟的方法。
3、内存管理a.首先，设计一个内存页框类，包含页框的基本属性（如页框号、状态等）和操作方法（如分配、回收等）。
b.然后，实现一个内存管理器，根据不同的内存保护机制对内存进行保护。
可以使用模拟的方法。
4、文件系统a.首先，设计一个文件类，包含文件的基本属性（如文件名、大小等）和操作方法（如创建、读取、写入、删除等）。
b.然后，实现一个文件系统管理器，包括文件的存储和检索功能。
计算机操作系统实验---进程调度
操作系统实验报告--进程调度计科02-8 王长青05年4月17日计算机操作系统实验——进程调度一．实验目的进程调度是处理机管理的核心内容。
通过本实验可以加深理解有关进程控制块、进程队列的概念，并体会和了解优先数调度算法的具体实施办法。
二．程序功能本程序使用VC++编译调试，用于实现进程优先数调度的模拟。
主要包含三个模块：1、主界面：用于显示进程调度的过程。
2、数据录入模块：用于获取进程的初始值，其中有三种获取方式，手动输入方式、随即生成方式和从文件中读去数据的方式。
当用户在主窗口中点击“开始”菜单项时即可打开数据录入对话框，用户通过这三种方式之一均可完成数据的录入。
3、进程控制模块：主要实现创建新的进程，就绪队列的管理，完成队列的管理，进程的调度。
三．实验原理（1）本程序采用优先数调度算法对进程进行调度，每个进程可有三个状态，即：就绪状态，运行状态，完成状态。
并假设初始状态为就绪状态。
这三种状态的转换情况如右图：（2）为了便于处理，程序中的某进程运行时间以时间片为单位计算。
各进程的优先数以及进程需运行的时间片数的初始值均由用户给定（通过数据录入模块完成）。
（3）程序通过设置一个定时器来实现时间片的轮转，时间片的大小是1秒，在定时器消息的响应函数中从用户录入的数据中读取一个创建进程，将其加入到就绪队列中，然后进行调度和执行。
在调度函数中，对于遇到优先数一致的情况，采用FIFO策略解决。
（4）在优先数算法中，进程每执行一次，优先数减3，进程还需要运行的时间数减1。
四．详细设计（1）设计进程控制块PCB结构：struct PCB{ int pid; //进程号int pri; //进程优先数int time; //进程所需运行时间int status; // 进程状态 0就绪，1 执行，-1完成};（2）将进程的各种操作封装在类CProMoni中，该类的定义如下：class CProMoni{public:CProMoni();virtual ~CProMoni();void InsertRQ(PCB* p); //将p所指的进程插入到就绪队列中void InsertFQ(PCB* p); //将p所指的进程插入到完成队列中void ProSchedule(); //进程调度函数void ProRun(); //运行函数void Display(CDC* pDC); //以表格形式输出运行过程bool GetFinishFlag();bool OpenLogFile(); //打开日志文件void CloseLogFile(); //关闭日志文件bool WriteLogToFile(); //向日志文件中写入数据private:PCB *m_pRunning; //指向当前运行的进程CPtrList m_readyList; //就绪队列CPtrList m_finishList; //完成队列bool m_finish; //完成标志CString m_LogFileName; //日志文件名CStdioFile m_LogFile; //日志文件public:int m_clock; //时钟序列};（3）主要成员函数的实现：void CProMoni::InsertRQ(PCB* p){ //将p插入到就绪队列中POSITION pre,pos=m_readyList.GetHeadPosition();PCB *q;while(pos!=NULL){pre=pos;q=(PCB*)m_readyList.GetNext(pos);if(q->pri < p->pri){m_readyList.InsertBefore(pre,p);return;}}if(pos==NULL){m_readyList.AddTail(p);}}void CProMoni::ProSchedule(){//进程调度PCB *p;if(m_pRunning==NULL){if(m_readyList.IsEmpty()){m_finish=true;return;}else{p=(PCB*)m_readyList.RemoveHead();m_pRunning=p;}}else{if(!m_readyList.IsEmpty()){p=(PCB*)m_readyList.GetHead();//m_readyList将头节点与当前PCB的权值比较if(p->pri > m_pRunning->pri ){PCB *q=m_pRunning;m_pRunning=(PCB*)m_readyList.RemoveHead();m_pRunning->status=1;q->status=0;InsertRQ(q);}}}}void CProMoni::ProRun(){//运行进程if(!m_finish){if(m_pRunning==NULL){ AfxMessageBox("当前运行的进程不存在!");return;}m_pRunning->pri-=3;m_pRunning->time-=1;{ m_pRunning->time=0;PCB*p=m_pRunning;p->status=-1;InsertFQ(p);m_pRunning=NULL;}}}（4）试图类的主要成员函数：PCB* CProcessView::CreatePCB(){//创建PCBPCB* p=new PCB;p->pid=n+1;p->pri=m_pris[n];p->time=m_times[n];p->status=0;n++;return p;}#include"pritimedlg.h"void CProcessView::OnStart(){ CPriTimeDlg dlg; //定义数据录入对话框dlg.DoModal();if(dlg.m_ok){ m_proTotal=dlg.m_proNum;for(int i=0;i<m_proTotal;i++){ m_pris[i]=dlg.m_pris[i];m_times[i]=dlg.m_times[i];}m_proMoni.OpenLogFile(); //打开日志文件PCB* p=CreatePCB(); //创建新进程m_proMoni.InsertRQ(p); //将新进程插入到就绪队列中m_proMoni.WriteLogToFile(); //写日志文件m_proMoni.ProSchedule(); //进程调度m_start=true; //设置开始标志Invalidate(); //刷新视图m_killTimer=false;SetTimer(1,1000,NULL);//设置定时器}}void CProcessView::OnTimer(UINT nIDEvent){ m_proMoni.m_clock++;m_proMoni.WriteLogToFile();//写日志m_proMoni.ProRun(); //运行进程if(n<m_proTotal){ PCB *p=CreatePCB();//创建新进程m_proMoni.InsertRQ(p);}m_proMoni.ProSchedule();Invalidate();if(m_proMoni.GetFinishFlag()){//若已完成则删除定时器KillTimer(1);m_killTimer=true;AfxMessageBox("演示完毕");}CScrollView::OnTimer(nIDEvent);}五．运行结果（1）数据录入界面：（2）进程调度过程的结果：六、实验总结通过本实验使我对进程的相关概念及进程的优先数调度算法有了更深的理解，使自己在程序设计及编制方面也有了一定的提高。
操作系统实验2进程调度 实验报告
（2）掌握带优先级的进程调度算法；
（3）选用面向对象的编程方法。
二、实验内容；
（1）用C语言（或其它语言，如Java）实现对N个进程采用动态优先调度算法的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：
进程标识数ID。
进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
4．可动态添加、删除进程；
5.完成所有进程操作。
五、程序源代码及注释
六、实验结果分析
1、运行结果如下：
2、结果分析
首先，每次从就绪队列中选择最高优先权的进程时，需要计算出最高优先权和次高优先权之间的STARTBLOCK。即最高优先权进程运行多少个时间片后就会进入阻塞队列。每调度一次，就需要更新所有进程的信息，并判断CPUTIME是否等于ALLTIME，如果相等，则进程完成操作，需从就绪队列中删除。如果阻塞队列中进程的BLOCKTIME为0时，还需要将其转移到就绪队列中。
（5）用户可以干预进程的运行状态，程序应该设置可以让用户中断的入口，并可以通过以下命令查看，修改，终止进程。
A）create随机创建进程，进程的优先级与所需要的时间片随机决定；
B）ps查看当前进程状态
C）sleep命令将进程挂起
D）kill命令杀死进程
E）quit命令退出
（5）分析程序运行的结果，谈一下自己的认识。
三、实验原理；
无论是在批处理系统还是分时系统中，用户进程数一般都多于处理机数、这将导致它们互相争夺处理机。另外，系统进程也同样需要使用处理机。这就要求进程调度程序按一定的策略，动态地把处理机分配给处于就绪队列中的某一个进程，以使之执行。
根据进程的五个特征：(1)动态性；(2)并发性；(3)异步性；(4)独立性；(5)结构性及三种基本状态的转换，了解各进程对资源的共享和竞争。进程并发执行时，由于资源共享，带来各进程之间的相互制约。为了反映这些制约关系和资源共享关系，在创建一个进程时，应首先创建其PCB，然后才能根据PCB中信息对进程实施有效的管理和控制。当一个进程完成其功能之后，系统则最后释放PCB，进程也随之消亡。
操作系统实验报告-单处理机系统的进程调度
实验二单处理机系统的进程调度一．实验目的（1）加深对进程概念的理解，明确进程与程序的区别。
（2）深入了解系统如何组织进程、创建进程。
（3）进一步认识如何实现处理机调度。
二．实验内容编写程序完成单处理机系统中的进程调度，要求采用时间片轮转调度算法。
三．实验原理在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.四．实验部分源程序#include<stdio.h>#include<time.h>#include<stdlib.h>/*********************以下是全局数据结构和变量***********************//*PCB 结构*/struct PCB{int pname;int pri;int runtime;int waittime;struct PCB *next;}pcb[7];struct PCB *running; /* 运行指针*/struct PCB *Hready; /*高优先级就绪队列头指针*/struct PCB *Lready; /*低优先级队列头指针*/struct PCB*wait; /*等待队列头指针*/int A=0;/**************************以下是函数说明****************************/ void delay(); /*利用循环实现延迟*/void proc(struct PCB *running); /*模拟进程3－9*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node); /*将node插入到head所指示的队列的尾部*/int proc_switch(); /*进程调度函数*/void proc_wait(); /*进程等待函数*/int proc_wakeup(); /*进程唤醒函数*//************************以下是函数定义及注释************************/ main() /*主函数*/{ int i;/*初始化，创建进程3－9，置低优先级，等待时间为0,依次插入低优先级队列*/for(i=0;i<3;i++){pcb[i].pname=i+3;pcb[i].pri=0;pcb[i].waittime=0;InsertIntoQueueTail(&Lready,&pcb[i]);}wait=NULL;Hready=NULL; /*等待队列和高优先级队列为空*/printf("\n模拟进程调度开始:\n"); /*模拟进程调度开始*/for(;;){ switch(A){case 0:/*无进程等待调度，打印信息并返回*/if(!proc_switch()){printf("/n没有进程在运行返回:\n");getchar(); }break;case 1:proc_wait();break;case 3:case 4:case 5:case 6:proc(running); break;default:printf("\nerror!");exit(-1); }}}/*功能：延迟一个时间片*//*入口参数：无*//*出口参数：无*/void delay(){ int i,j;for(i=0;i<20000;i++)for(j=0;j<10000;j++){}}/*功能：进程3－9*//*入口参数：运行指针*//*出口参数：无*/void proc(struct PCB * running){ int i;srand( (unsigned)time( NULL ) );/*显示当前运行的进程的id*/printf("\n现在进程%d 正在运行\n",running->pname);/*当前进程执行running->runtime个时间片*/for(i=running->runtime;i>0;i--){/*显示剩余的时间片*/printf("剩余的时间片为%d\n",i);/*延迟*/delay();proc_wakeup();/*产生一个1到1000的随机数，若该随机数小余300，当前进程等待，*/ if((rand()%1000+1)<300){printf("进程%d开始等待.\n",running->pname);A=1;return; }}/*显示时间片耗尽，进程转为低优先级就绪状态*/printf("进程%d时间片耗尽\n",running->pname);InsertIntoQueueTail(&Lready,running);A=0;return; }/*功能：将一个节点插入队列尾部*//*入口参数：队列头指针地址head，待插入结点node*//*出口参数：无*/void InsertIntoQueueTail(struct PCB **head,struct PCB *node){ struct PCB *p;node->next=NULL;/*被插入队列为空*/if(*head==NULL){*head=node;return; }/*被插入队列不为空*/else{p=*head;/*找到队列的最后一个结点*/while(p->next!=NULL)p=p->next; p->next=node; }}/*功能：进程调度*//*入口参数：无*//*出口参数：若调度成功，返回1，否则返回0*/int proc_switch() {/*若高优先级就绪队列和低优先级就绪队列均为空，则循环执行进程唤醒*/while(Hready == NULL && Lready == NULL)if(!proc_wakeup()) return 0;/*若高优先级就绪队列非空，则执行其第一个进程，分配2个时间片*/if(Hready!=NULL){running=Hready;Hready=Hready->next;running->runtime=2; }/*若高优先级就绪队列为空，则执行低优先级就绪队列的第一个进程，分配5个时间片*/else{running=Lready;Lready=Lready->next;running->runtime=5; }/*把调度进程的id赋给A*/A=running->pname;return 1; }/*功能：进程等待。
操作系统实验二进程调度
操作系统实验二进程调度摘要：进程调度是操作系统中重要的功能之一，可以决定进程的优先级和执行顺序。
本实验主要介绍了进程调度的概念、不同的调度算法以及如何实现进程调度。
一、概念介绍进程调度是操作系统中的一项重要功能，用于决定哪个进程能够在处理器上运行。
在操作系统中存在多个进程需要同时运行，而处理器资源有限，因此需要通过进程调度来合理地安排进程的执行顺序，提高系统的效率。
进程调度的目标是使系统的吞吐量最大化、响应时间最短、资源利用率最高等。
常见的调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转、优先级调度等。
二、调度算法介绍1.先来先服务（FCFS）先来先服务（FCFS）是最简单的调度算法，按照进程到达的顺序进行调度，先到达的进程先执行。
FCFS算法不考虑进程的优先级和执行时间，容易导致平均等待时间长。
2.最短作业优先（SJF）最短作业优先（SJF）调度算法按照进程所需的CPU时间进行排序，优先调度所需时间最短的进程。
SJF算法可以减少平均等待时间，但可能会导致长作业等待时间过长。
3.时间片轮转时间片轮转是一种抢占式调度策略，将处理器的使用权分割为若干个时间片，每个进程在一个时间片内运行，如果时间片用完仍未运行完，则将该进程放到队列的末尾，并让下一个进程运行。
时间片轮转算法保证了公平性和响应时间，但可能会导致上下文切换次数过多。
4.优先级调度优先级调度是根据进程的优先级进行调度，优先级高的进程先执行。
优先级可以根据进程类型、实时性等因素确定，不同的操作系统可能有不同的优先级范围和策略。
三、实验步骤1.定义进程结构：定义进程结构体，包含进程ID、进程状态、优先级、执行时间等信息。
2.初始化进程队列：将所有进程按照到达的先后顺序加入到进程队列中。
3.实现调度算法：根据不同的调度算法，实现相应的进程调度算法代码。
可以使用循环遍历进程队列，并根据不同的调度策略决定下一个要执行的进程。
4.执行进程调度：在每个时间片结束后，根据调度算法选取下一个要执行的进程，并更新进程的状态和执行时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二进程调度算法的设计一、实验内容实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR）二、实验目的通过对进程调度算法的设计，深入理解进程调度的原理。
进程是程序在一个数据集合上运行的过程，它是系统进行资源分配和调度的一个独立单位。
进程调度分配处理机，是控制协调进程对CPU的竞争，即按一定的调度算法从就绪队列中选中一个进程，把CPU的使用权交给被选中的进程。
进程通过定义一个进程控制块的数据结构（PCB）来表示；每个进程需要赋予进程ID、进程到达时间、进程需要运行的总时间的属性；在RR中，以1为时间片单位；运行时，输入若干个进程序列，按照时间片输出其执行序列。
三、实验题目实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR）[提示]：(1) 先来先服务（FCFS）调度算法原理：每次调度是从就绪队列中，选择一个最先进入就绪队列的进程，把处理器分配给该进程，使之得到执行。
该进程一旦占有了处理器，它就一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。
将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列，并按照先来先服务的方式进行调度处理，是一种最普遍和最简单的方法。
它优先考虑在系统中等待时间最长的作业，而不管要求运行时间的长短。
按照就绪进程进入就绪队列的先后次序进行调度，简单易实现，利于长进程，CPU繁忙型作业，不利于短进程，排队时间相对过长。
(2) 时间片轮转调度算法RR原理：时间片轮转法主要用于进程调度。
采用此算法的系统，其程序就绪队列往往按进程到达的时间来排序。
进程调度按一定时间片（q）轮番运行各个进程.进程按到达时间在就绪队列中排队，调度程序每次把CPU分配给就绪队列首进程使用一个时间片，运行完一个时间片释放CPU，排到就绪队列末尾参加下一轮调度，CPU分配给就绪队列的首进程。
固定时间片轮转法：1 所有就绪进程按 FCFS 规则排队。
2 处理机总是分配给就绪队列的队首进程。
3 如果运行的进程用完时间片，则系统就把该进程送回就绪队列的队尾，重新排队。
4 因等待某事件而阻塞的进程送到阻塞队列。
5 系统把被唤醒的进程送到就绪队列的队尾。
可变时间片轮转法：1 进程状态的转换方法同固定时间片轮转法。
2 响应时间固定，时间片的长短依据进程数量的多少由T = N × （q + t ）给出的关系调整。
3 根据进程优先级的高低进一步调整时间片，优先级越高的进程，分配的时间片越长。
多就绪队列轮转法：(3) 算法类型(4)模拟程序可由两部分组成，先来先服务（FCFS）调度算法，时间片轮转。
流程图如下:(5) 按模拟算法设计程序，运行设计的程序，观察得到的结果。
四、主要数据结构每一个进程用一个进程控制块PCB 表示，参考的proc 结构定义如下：struct proc {char p_pid; //进程标识数char p_pstat; //进程状态caddr_t p_addr; //进程图象在内存中首址int p_size; //进程图象的长度char p_pri; //进程优先数char p_cpu; //进程当前运行的时间int p_time; //作业运行的（剩余）总时间char p_wchan; //进程睡眠原因structproc *p_next, *p_prior;//进程proc 的双向链指针}系统中有一个全局变量curproc 指向现运行进程，还要定义几个队列的首指针。
本来记错了题目，就写了优先级调度了，后来就改了一下变成了短进程优先算法。
代码如下：#include <iostream>#include <vector>#include <algorithm>#include <iomanip>#include <ctime>using namespace std;//优先权法pcbclass PCB//类定义PCB表，适用于优先数{public:int ID;int priority;int CPUtime;//runnedtimeint ALLtime;//needtimeint State;//1ready 2runing 3finishint flag;//flag=1 finishedvoid set_PCB(int a,int b,int c,int d, int e,int f){ID=a;priority = b;CPUtime=c;ALLtime=d;State=e;flag=f;}};//轮转法pcbclass PCB2{public:int ID;int CPUtime;int ALLtime;int State;int flag;void set_PCB2(int a,int b,int c,int d, int e){ID=a;CPUtime=b;ALLtime=c;State=d;flag=e;}};bool priority_sort_higher(const PCB &m, const PCB &n)//sort函数，定义按优先数排序，当优先数相同时按序号排序（即先进先出）/priority high idsmall{if(m.priority == n.priority) return m.ID< n.ID;return m.priority > n.priority;}bool ALLtime_sort_higher(const PCB &m, const PCB &n)//sort函数，短时间优先数排序{if(m.ALLtime == n.ALLtime) return m.ID< n.ID;return m.ALLtime < n.ALLtime;}void priority_way(vector<PCB> &pcb, vector<PCB> &wait,int pcbnum)//优先数算法{vector<PCB>::iterator it1;it1 = pcb.begin();int flag = pcbnum;while(flag){wait.erase(wait.begin());(*it1).State = 2;(*it1).priority -= 3;(*it1).CPUtime += 1;(*it1).ALLtime -= 1;if((*it1).ALLtime == 0){flag -= 1;(*it1).flag =1;cout<<left<<setw(10)<<(*it1).ID<<setw(10)<<(*it1).State<<setw(10)<<(*it1).priority<<setw(10) <<(*it1).CPUtime<<setw(10)<<(*it1).ALLtime<<setw(10)<<(*it1).flag<<endl;pcb.erase(pcb.begin());sort(wait.begin(), wait.end(),priority_sort_higher);sort(pcb.begin(), pcb.end(),priority_sort_higher);}else{cout<<left<<setw(10)<<(*it1).ID<<setw(10)<<(*it1).State<<setw(10)<<(*it1).priority<<setw(10) <<(*it1).CPUtime<<setw(10)<<(*it1).ALLtime<<setw(10)<<(*it1).flag<<endl;(*it1).State = 1;wait.push_back(*it1);sort(wait.begin(),wait.end(),priority_sort_higher);sort(pcb.begin(),pcb.end(),priority_sort_higher);}}}void ALLtime_way(vector<PCB> &pcb, vector<PCB> &wait,int pcbnum)//短进程算法{vector<PCB>::iterator it1;it1 = pcb.begin();int flag = pcbnum;while(flag){wait.erase(wait.begin());(*it1).State = 2;//(*it1).priority -= 3;(*it1).CPUtime += 1;(*it1).ALLtime -= 1;if((*it1).ALLtime == 0){flag -= 1;(*it1).flag =1;cout<<left<<setw(10)<<(*it1).ID<<setw(10)<<(*it1).State<</*setw(10)<<(*it1).priority<<*/setw (10)<<(*it1).CPUtime<<setw(10)<<(*it1).ALLtime<<setw(10)<<(*it1).flag<<endl;pcb.erase(pcb.begin());//sort(wait.begin(), wait.end(),ALLtime_sort_higher);//sort(pcb.begin(), pcb.end(),ALLtime_sort_higher);}else{cout<<left<<setw(10)<<(*it1).ID<<setw(10)<<(*it1).State<</*setw(10)<<(*it1).priority<<*/setw (10)<<(*it1).CPUtime<<setw(10)<<(*it1).ALLtime<<setw(10)<<(*it1).flag<<endl;(*it1).State = 1;wait.push_back(*it1);//sort(wait.begin(),wait.end(),ALLtime_sort_higher);//sort(pcb.begin(),pcb.end(),ALLtime_sort_higher);}}}void round_robin_way(vector<PCB2> &pcb2,vector<PCB2> &wait2,int pcbnum)//时间片{vector<PCB2>::iterator it2;it2 = wait2.begin();int flag=pcbnum;while(flag){it2 = pcb2.begin();wait2.erase(wait2.begin());//出队（等待队列）(*it2).State = 2;if((*it2).ALLtime==1){(*it2).CPUtime +=1;(*it2).ALLtime -=1;flag -= 1;(*it2).flag = 1;cout << left <<setw(10) << (*it2).ID << setw(10) <<(*it2).State<<setw(10)<<(*it2).CPUtime<<setw(10)<<(*it2).ALLtime<<setw(10)<<(*it2).flag <<endl;pcb2.erase(pcb2.begin());continue;}else if((*it2).ALLtime==2){(*it2).CPUtime +=2;(*it2).ALLtime -=2;flag-=1;(*it2).flag =1;cout<<left<<setw(10)<<(*it2).ID<<setw(10)<<(*it2).State<<setw(10)<<(*it2).CPUtime<<setw(1 0)<<(*it2).ALLtime<<setw(10)<<(*it2).flag<<endl;pcb2.erase(pcb2.begin());continue;}else{(*it2).State = 2;(*it2).CPUtime +=2;(*it2).ALLtime -=2;cout<<left<<setw(10)<<(*it2).ID<<setw(10)<<(*it2).State<<setw(10)<<(*it2).CPUtime<<setw(1 0)<<(*it2).ALLtime<<setw(10)<<(*it2).flag<<endl;(*it2).State = 2;wait2.push_back(*it2);PCB2 q = *it2;pcb2.erase(pcb2.begin());pcb2.push_back(q);//pcb2.push_back(*it2);}}}int random(int start, int end){return start+(end-start)*rand()/(RAND_MAX +1.0);}int main( ){srand(unsigned(time(0)));int flag_0;cout<<"请输入想要模拟进程调度算法的编号"<<endl;cout<<"1.短时间调度；2.时间片轮转调度。