实验一___处理器调度(设计一个按时间片轮转法实现处理器调度的程序)

处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下处理器调度，帮助学生加深了解处理器调度的工作。

三、实验题目设计一个按优先数调度算法实现处理器调度的程序提示：（1）假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：其中，进程名----作为进程的标识，假设五个进程的进程名分别是R, P2, P3，P4，R。

指针—按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块首地址，最后一个进程中的指针为“ 0”。

要求运行时间-- 假设进程需要运行的单位时间数。

优先数-赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态-可假设有两种状态，“就绪”状态和“结束“状态，五个进程的初始状态都为“就绪“状态，用“ R”表示，当一个进程运行结束后，它的状态变为“结束”，用“ E”表示。

（2）在每次运行你所设计的处理器调度程序之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

（3）为了调度方便，把五个进程按给定的优先数从大到小连成队列，用一单元指出队首进程，用指针指出队列的连接情况。

例：队首标志（4）处理器调度总是选队首进程运行。

采用动态改变优先数的办法，进程每运行一次优先数就减“ 1”。

由于本实验是模拟处理器调度，所以，对被选中的进程并不实际的启动运行，而是执行：优先数－ 1 要求运行时间－1来模拟进程的一次运行提醒注意的是：在实际的系统中，当一个进程被选中运行时，必须恢复进程的现场，它占有处理器运行，直到出现等待事件或运行结束。

在这里省去了这些工作。

(5)进程运行一次后，若要求运行时间工0,则再将它加入队列(按优先数大小插入，且置队首标志)；若要求运行时间=0,则把它的状态修改为“结束”(),且退出队列。

设计一个按优先数调度算法实现处理器调度的程序处理器调度是操作系统中重要的任务之一，负责决定在多个可执行任务之间如何分配处理器时间。

在处理器调度中，按优先数调度算法是一种常见的策略。

本文将介绍如何设计一个按优先数调度算法实现处理器调度的程序。

一、定义任务在实现处理器调度之前，首先需要定义可执行的任务。

一个任务可以由多个属性来描述，包括优先级、到达时间、执行时间等。

在按优先数调度算法中，每个任务都有一个优先级，优先级越高表示任务的重要性越高。

同时，每个任务还有一个到达时间，即任务进入调度器的时间点。

最后，每个任务还有一个执行时间，表示任务完成所需要的时间。

二、设计数据结构为了表示任务，我们可以使用一个Task类来封装任务的属性，例如：```class Taskint priority; // 优先级int arrivalTime; // 到达时间int executionTime; // 执行时间};```此外，为了管理所有待调度的任务，需要使用一个队列来存储任务。

我们可以使用优先队列（Priority Queue）来实现这个队列，其中任务按照优先级的顺序排列。

当一个任务到达时，将其插入到优先队列中；当处理器空闲时，从优先队列中选择优先级最高的任务进行调度。

三、实现调度算法接下来，需要实现按优先数调度算法。

按照该算法的步骤，当一个任务到达时，将其插入到优先队列中。

当处理器空闲时，从队列中取出优先级最高的任务，并执行该任务。

如果任务未完成，则将其重新插入队列中。

如果所有任务都已完成，则调度任务结束。

以下是一个示例的按优先数调度算法实现：```PriorityQueue<Task> taskQueue; // 优先队列，按优先级排序任务void schedule(int currentTime)if (taskQueue.isEmpty()System.out.println("Processor is idle.");return;}Task currentTask = taskQueue.poll(; // 取出优先级最高的任务int remainingTime = currentTask.executionTime - (currentTime - currentTask.arrivalTime);if (remainingTime > 0)currentTask.executionTime = remainingTime;taskQueue.add(currentTask); // 将未完成的任务重新插入队列中} else}```四、模拟调度过程最后，我们可以编写一个简单的模拟函数来模拟调度器的执行过程：```void simulatint currentTime = 0; // 当前时间while (!taskQueue.isEmpty()while (!taskQueue.isEmpty( && taskQueue.peek(.arrivalTime <= currentTime)Task newTask = taskQueue.poll(;System.out.println("New task with priority " +newTask.priority + " arrived at " + currentTime + ".");taskQueue.add(newTask); // 插入新到达的任务}schedule(currentTime);currentTime++;}```在模拟函数中，我们不断地增加当前时间，直到所有任务都已完成。

设计一个按优先数调度算法实现处理器调度的进程
一．处理器调度的简介
处理器调度是指在若干作业并发处理时，对处理器分配工作的动态过程。

它是操作系统中的一种重要技术，其主要功能是控制并发作业的执行，使他们得到公平的分配，正确的完成执行，以达到有效利用处理机资源，
提高系统的工作效率。

处理器调度技术包括：处理机调度算法、处理机调
度技术等。

处理机调度算法就是基于计算机系统的工作机制，根据不同的作业在
处理机上的执行情况，系统在不同的阶段，根据量的不同，采用不同的算法，按优先级、分时等原则进行处理机调度，使作业在不同的阶段得到公
平的分配，以达到有效利用处理机资源，提高系统工作效率的目的。

按优先数调度算法( Priority Scheduling Algorithm )是指根据作
业的优先级先后来分配处理机资源，使作业能够按照优先级依次被处理，
使得系统性能有所提高。

1．处理器调度的算法流程
按优先数调度算法的处理器调度的过程，如下：
首先，从队列中取出一个作业，检查是否具有最高优先级，如果是，
则将其分配给处理机，否则，该作业放回队列，继续下一步判断；
其次，在没有作业可以处理时，处理机将停止运转。

实验2 处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三、实验题目按时间片轮转法实现处理器调度的模拟设计与实现四、源代码#include<iostream>#include<string>using namespace std; //-----------------------struct _proc {char name[32];struct _proc *next;int run_time;int alloc_time;int state;//就绪为};_proc *root;//向就绪队列中插入进程,按照降序void Insert(_proc* pr) {if(root->next==NULL){root=pr;pr->next=pr;return;}pr->next=root->next;//插入root->next=pr;root=pr;}//创建进程_proc Creat(char name[],int run_time,int alloc_time) { _proc pr;strcpy(,name);pr.run_time=run_time;pr.alloc_time=alloc_time;pr.state=0;pr.next=NULL;return pr;}//删除就绪队列中对首进程void Delete() {if(root->next==root){root=NULL;return;}root->next=root->next->next;}//输出进程号,模拟进程执行void OutPut() {cout<<root->next->name<<endl;//输出，模拟进程执行++root->next->alloc_time;//修改进程}void Solve() {//根结点root=new _proc;root->state=0;//state记录就绪队列中的进程个数root->next=NULL;//空循环链表，指向自身//创建几个进程,并插入就绪队列_proc pr1=Creat("Q1",2,1);Insert(&pr1);_proc pr2=Creat("Q2",3,0);Insert(&pr2);_proc pr3=Creat("Q3",1,0);Insert(&pr3);_proc pr4=Creat("Q4",2,0);Insert(&pr4);_proc pr5=Creat("Q5",4,0);Insert(&pr5);cout<<"调度序列："<<endl;while(root!=NULL)//一直循环遍历{OutPut();//执行root指向的进程//执行完毕即：run_time==alloc_time，从队列中删除该进程if(root->next->alloc_time==root->next->run_time)//执行完毕{Delete();//从就绪队列中，删除该进程continue;}root=root->next;//root指针后移，执行下一个进程做准备}}int main() {Solve();getchar();getchar();return 0;}五、实验结果。

实验一处理机调度实验报告一、实验目的处理机调度是操作系统中的一个重要组成部分，其目的是合理地分配处理机资源，以提高系统的性能和效率。

本次实验的主要目的是通过模拟处理机调度算法，深入理解不同调度算法的工作原理和性能特点，并能够对它们进行比较和分析。

二、实验环境本次实验使用了以下软件和工具：1、操作系统：Windows 102、编程语言：Python3、开发环境：PyCharm三、实验内容1、先来先服务（FCFS）调度算法先来先服务调度算法按照作业或进程到达的先后顺序进行调度。

即先到达的作业或进程先得到处理机的服务。

2、短作业优先（SJF）调度算法短作业优先调度算法优先调度运行时间短的作业或进程。

在实现过程中，需要对作业或进程的运行时间进行预测或已知。

3、高响应比优先（HRRN）调度算法高响应比优先调度算法综合考虑作业或进程的等待时间和运行时间。

响应比的计算公式为：响应比＝（等待时间＋要求服务时间）／要求服务时间。

4、时间片轮转（RR）调度算法时间片轮转调度算法将处理机的时间分成固定大小的时间片，每个作业或进程在一个时间片内运行，当时间片用完后，切换到下一个作业或进程。

四、实验步骤1、设计数据结构为了表示作业或进程，设计了一个包含作业或进程 ID、到达时间、运行时间和等待时间等属性的数据结构。

2、实现调度算法分别实现了上述四种调度算法。

在实现过程中，根据算法的特点进行相应的处理和计算。

3、模拟调度过程创建一组作业或进程，并按照不同的调度算法进行调度。

在调度过程中，更新作业或进程的状态和相关时间参数。

4、计算性能指标计算了平均周转时间和平均带权周转时间等性能指标，用于评估不同调度算法的性能。

五、实验结果与分析1、先来先服务（FCFS）调度算法平均周转时间：通过计算所有作业或进程的周转时间之和除以作业或进程的数量，得到平均周转时间。

在 FCFS 算法中，由于按照到达顺序进行调度，可能会导致长作业或进程长时间占用处理机，从而使平均周转时间较长。

一、实验目的1. 理解处理器调度的基本概念和原理；2. 掌握常用的处理器调度算法，如先来先服务（FCFS）、短作业优先（SJF）、优先级调度等；3. 分析不同调度算法的性能指标，如平均周转时间、平均带权周转时间等；4. 通过实验，提高实际操作和编程能力。

二、实验原理处理器调度是操作系统中的一个重要组成部分，其主要任务是合理分配处理器资源，使系统中的多个进程高效、有序地运行。

常见的处理器调度算法有以下几种：1. 先来先服务（FCFS）：按照进程到达就绪队列的顺序进行调度，先到先服务；2. 短作业优先（SJF）：优先选择运行时间最短的进程执行；3. 优先级调度：根据进程的优先级进行调度，优先级高的进程先执行；4. 时间片轮转（RR）：将每个进程分配一个时间片，按照时间片轮转的方式调度进程。

三、实验内容1. 实验环境：Windows操作系统，Python编程语言；2. 实验工具：Python编程环境，如PyCharm、Spyder等；3. 实验步骤：（1）设计一个进程类，包含进程名、到达时间、运行时间、优先级等属性；（2）编写调度算法，实现FCFS、SJF、优先级调度和时间片轮转算法；（3）模拟进程执行过程，记录各个进程的执行时间、等待时间、周转时间等性能指标；（4）分析不同调度算法的性能，比较其优劣。

四、实验结果与分析1. FCFS调度算法实验结果：平均周转时间为20，平均带权周转时间为1.25。

分析：FCFS调度算法简单易实现，但可能导致进程响应时间长，不利于实时性要求高的系统。

2. SJF调度算法实验结果：平均周转时间为16，平均带权周转时间为1.2。

分析：SJF调度算法可以缩短平均周转时间，提高系统性能，但可能使长作业长时间等待，影响公平性。

3. 优先级调度算法实验结果：平均周转时间为18，平均带权周转时间为1.3。

分析：优先级调度算法可以根据进程的优先级进行调度，提高系统响应速度，但可能导致低优先级进程长时间等待。

操作系统实验一报告一．实验内容选择一个调度算法，实现处理器调度。

二．实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下处理器调度，帮助学生加深了解处理器调度的工作。

三．实验要求设计一个按优先数调度算法实现处理器调度的进程。

YNY上面的过程只给出了 那个寻找以及排序的大体过程，具体的过程太多画不下。

寻找优先级最高节点是否最高优先级优先数减一 运行时间减一继续寻找节点 运行时间是否为0删除节点 按优先级重新排序四．实验程序这个实验的程序使用的visual studio 2008 的c++ win控制台写的，所以可能老师的电脑里面。

我把程序结果贴在后面，还有第二题我也做了，但只要求写一个，那么。

// 操作系统实验.cpp : 定义控制台应用程序的入口点。

//#include"stdafx.h"#include<iostream>#include<string>using namespace std;static int num=0;class proc{private: string procname;proc * next;int time;int priority;char state;public:proc(){proc*next=new proc();}proc(string pr,proc * ne,int ti,int pri,char st):procname(pr),next(ne),time(ti),priority(pri),state(st){}~proc(){}void setnext(proc * n){next=n;}void setprocname(string s){procname=s;}void settime(int t){time=t;}void setpriority(int s){priority=s;}void setstate(char s){state=s;}proc * getnext(){return next;}string getprocname(){return procname;}int gettime(){return time;}int getpriority(){return priority;}char getstate(){return state;}};class dui{private:proc * first;public:dui(){first=new proc();}dui(proc*f){ first=f;}int getfirst_time(){return first->gettime();}void show(proc*p){cout<<"名字"<<"下个节点的名字"<<" "<<"时间"<<"优先级"<<"状态"<<endl;while(p){cout<<p->getprocname ()<<" "<<((p->getnext()!=NULL)?p->getnext ()->getprocname ():"NU")<<" "<<p->gettime ()<<" "<<p->getpriority()<<" "<<((p->gettime ()!=0)?p->getstate():'E')<<endl;p=p->getnext ();}cout<<"..............................................................."<<endl;}void process1(){proc*pp=first;show(first);while( first->getnext ()!=NULL){proc*pp_next=pp->getnext ();int a,b;a=pp->getpriority()-1;b=pp->gettime()-1;pp->setpriority(a);pp->settime(b);if(b==0){show(pp);pp =first=first->getnext ();continue;}int prio1,prio2;prio2=first->getnext ()->getpriority();prio1=pp->getpriority();if(prio1>=prio2){show(pp); }else{while(prio1<prio2){first=first->getnext ();if(first->getnext ()==NULL){first->setnext (pp);pp->setnext (NULL);break;}else prio2=first->getnext ()->getpriority(); }if(prio1>=prio2){pp->setnext (first->getnext ());first->setnext (pp);show(pp_next);}if(pp->getnext ()==NULL){show(pp_next); }pp=pp_next;first=pp;}}if(first->getnext ()==NULL)while(first->gettime()>0){int t=first->gettime()-1;first->settime(t);show(first);cout<<"五";}}};int main(){proc * A=new proc("p1",NULL,2,1,'R');proc * B=new proc("p2",NULL,3,5,'R');proc * C=new proc("p3",NULL,1,3,'R');proc * D=new proc("p4",NULL,2,4,'R');proc * E=new proc("p5",NULL,4,2,'R');B->setnext (D);D->setnext (C);C->setnext (E);E->setnext (A);dui aaa(B);//aaa.setfirst (B);aaa.process1 ();cin.get();return 0 ;}五．实验结果六．实验总结这个说来惭愧啊，因为自己的这个程序早就做好了，就是对进程啊什么的还不是很了解，因为自己不是学习认真的那一种，这个老师的那些问题把我给郁闷了好多天啊！悲剧！以后还是要好好学习，课后不能再玩得那么狠了！通过这个程序，我体会到了些程序前先把图给画出来是都么好的习惯啊！以后要多多用！还有我的电脑因为不知道什么病毒，c盘重还原了一下，原来在桌面的那个报告比这个更详细，这次因为不能上传加上自己没有保存就丢失了那个报告，临时写的这个希望老师不要怪我！！最后希望老师弄一下，最起码我们可以在机房里上传到ftp中!!!。

实验报告2012 ～2013 学年第一学期课程操作系统原理实验名称设计一个按优先数调度算法实现处理器调度的进程小组成员阮广杰、陈智磊、高天翔、董云鹏专业班级10级计本三班指导教师屠菁2012 年11 月29号操作系统实验报告实验目的：在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下处理器调度，设计一个按优先数调度算法实现处理器调度的进程，通过运行程序，能够清楚的表述优先数调度的过程，进一步掌握优先数调度算法的实现。

实验内容：设计一个按优先数调度算法实现处理器调度的进程。

实验步骤：概要设计：(1)假定系统有5个进程，每个进程用一个PCB来代表。

PCB的格式为：进程名、指针、要求运行时间、优先数、状态。

进程名——P1~P5。

指针——按优先数的大小把5个进程连成队列，用指针指出下一个进程PCB 的首地址。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——假设两种状态，就绪，用R表示，和结束，用E表示。

初始状态都为就绪状态。

(2) 每次运行之前，为每个进程任意确定它的“优先数”和“要求运行时间”。

(3) 处理器总是选队首进程运行。

采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。

(4) 进程运行一次后，若要求运行时间不等于0，则将它加入队列，否则，将状态改为“结束”，退出队列。

(5) 若就绪队列为空，结束，否则，重复(3)。

详细设计：1、程序中使用的数据结构及符号说明：typedef struct PCB{char name[50];// 进程名以序号代替LPVOID lp;// 指向进程的长指针，模拟的，所以没用到。

int tm;// 需要运行的时间int prior;// 初始的优先数char state;// 状态struct PCB *next; // 指向下一个PCB块}PCB;3、源程序清单：//Main.cpp// prior.cpp : Defines the entry point for the application.//#include "stdafx.h"#include "resource.h"#include "MainDlg.h"#include <COMMCTRL.H>int APIENTRY WinMain(HINSTANCE hInstance,//当前进程句柄HINSTANCE hPrevInstance,// 前次进程句柄LPSTR lpCmdLine,// 启动信息int nCmdShow)//{//Enable IPAddress、Calendar.etcInitCommonControls();//系统调用函数DialogBox(hInstance, MAKEINTRESOURCE(IDD_MAIN), NULL, Main_Proc);return 0;}//MainDlg.cpp#include "stdafx.h"#include <windows.h>#include <windowsx.h>#include "resource.h"#include "MainDlg.h"#include "cross.h"#include "time.h"int MAX_NUM;// 用户输入进程数char *pst1="------------------------------------------------------------------------------\r\n"; char *pst2="=======================================\r\n";typedef struct PCB{char name[50];// 进程名以序号代替LPVOID lp;// 指向进程的长指针，模拟的，所以没用到。

操作系统实验一处理机调度算法的实现操作系统中的处理机调度算法是为了合理地分配和利用处理器资源，提高系统的性能和响应速度。

这些算法主要用于决定下一个要执行的进程或线程。

在本篇文章中，我们将介绍几种常见的处理机调度算法以及它们的实际应用。

首先，我们要了解什么是处理机调度算法。

处理机调度是指从就绪队列中选择一个进程，并分配处理机给它。

调度算法的目标是合理地选择进程，以达到最佳的系统性能指标。

这些指标可以包括响应时间、吞吐量、公平性等。

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

这种算法按照进程到达的顺序来进行调度。

当一个进程完成后，下一个进程在队列头被选中执行。

FCFS算法的优点是实现简单，但缺点是不考虑进程的执行时间，导致平均等待时间较长。

FCFS主要用于批处理环境中，例如打印任务的排队。

另一种常见的调度算法是短作业优先（SJF）。

这种算法选择剩余执行时间最短的进程进行调度。

为了实现SJF算法，系统需要预测进程的执行时间，这可能是一个难题。

SJF算法的优点是能够最小化平均等待时间，但缺点是可能导致长作业的饥饿。

SJF算法主要用于交互式系统或具有预测性能的任务。

另一个常见的调度算法是轮转调度（RR）。

这种算法将处理机时间分成一定大小的时间片（时间片就是一段处理器运行的时间），每个进程在一个时间片内执行，然后进入队列尾部等待。

轮转调度算法的目的是实现公平性，每个进程都有机会被执行。

RR算法的优点是能够减少各个进程的响应时间，但缺点是可能造成高负载下的处理机浪费。

RR算法主要用于实时系统或多用户环境。

另一个调度算法是最高响应比优先（HRRN）。

响应比是指进程等待时间与预计执行时间的比率。

HRRN算法选择响应比最高的进程进行调度。

这种算法考虑了等待时间和执行时间的权衡，能够实现较好的性能。

但是，HRRN算法计算响应比需要实时监测和更新进程的等待时间和执行时间。

HRRN算法适用于交互式或多用户系统。

还有一种常见的调度算法是最短剩余时间优先（SRTF）。

操作系统实验⼀：处理器调度算法的实现⼀、实验⽬的（1）加深对处理机调度的作⽤和⼯作原理的理解。

（2）进⼀步认识并发执⾏的实质。

⼆、实验要求：本实验要求⽤⾼级语⾔，模拟在单处理器情况下，采⽤多个调度算法，对N个进程进⾏进程调度。

语⾔⾃选。

并完成实验报告。

三、实验内容：在采⽤多道程序设计的系统中，往往有若⼲个进程同时处于就绪状态。

当就绪状态进程个数⼤于处理器数时，就必须依照某种策略来决定哪些进程优先占⽤处理器。

1. 进程及进程队列的表⽰。

2. 处理器调度算法：FCFS，SJF，RR，HRRN，MLFQ等3. 跟踪进程状态的转化4. 输出：系统中进程的调度次序，计算CPU利⽤率，平均周转时间和平均带权周转时间四、实验过程与结果1. RR:1.1 算法思想：CPU时间划分为时间⽚，例如100ms时间⽚调度：调度程序每次把CPU分配给就绪队列⾸进程使⽤⼀个时间⽚，就绪队列中的每个进程轮流地运⾏⼀个时间⽚。

当这个时间⽚结束时，强迫⼀个进程让出处理器，让它排列到就绪队列的尾部，等候下⼀轮调度1.2 算法设计：（采⽤描述或程序流程图）Ø进程排序Ø队列不为空时循环：Ø到达？Ø剩余服务时间>时间⽚Ø运⾏时间Ø剩余服务时间Ø剩余服务时间<=时间⽚Ø运⾏时间Ø剩余服务时间、完成时间、周转时间、加权周转时间Ø保存Ø从队列删除进程1.3 算法实现代码package ss;public class Model {private String ProcessName;private int startTime;private int needTime;private int leftTime;private int finishTime;private int cyclingTime;private int QuanTime;public String getProcessName() {return ProcessName;}public void setProcessName(String processName) { ProcessName = processName;}public int getStartTime() {return startTime;}public void setStartTime(int startTime) {this.startTime = startTime;}public int getNeedTime() {return needTime;}public void setNeedTime(int needTime) {this.needTime = needTime;}public int getLeftTime() {return leftTime;}public void setLeftTime(int leftTime) {this.leftTime = leftTime;}public int getFinishTime() {return finishTime;}public void setFinishTime(int finishTime) {this.finishTime = finishTime;}public int getCyclingTime() {return cyclingTime;}public void setCyclingTime(int cyclingTime) {this.cyclingTime = cyclingTime;}public int getQuanTime() {return QuanTime;}public void setQuanTime(int quanTime) {QuanTime = quanTime;}public Model(String name, int start, int need, int left, int finish,int cycle, int quan) {// TODO Auto-generated constructor stubthis.ProcessName=name;this.startTime=start;this.needTime=need;this.leftTime=left;this.finishTime=finish;this.cyclingTime=cycle;this.QuanTime=quan;}public Model() {// TODO Auto-generated constructor stubthis.ProcessName="name";this.startTime=0;this.needTime=0;this.leftTime=0;this.finishTime=0;this.cyclingTime=0;this.QuanTime=0;}}package ss;import java.util.Scanner;public class Test {public static void main(String[] args) {// 动态输⼊信息到控制台 Scanner java.util// Scanner in=new Scanner(System.in);//通过new关键字创建了⼀个Scanner对象 // 类似于扫描仪// System.out.println("请输⼊⼀个进程数：");// int number=in.nextInt();// TODO Auto-generated method stub@SuppressWarnings("unused")// Model process=new Model("A",12.10,12.00，);// System.out.println(process.getProcessName());int num=5;Model arrayName[] = new Model[num];arrayName[0] = new Model("A", 0, 4, 4, 0, 0, 0);arrayName[1] = new Model("B", 1, 3, 3, 0, 0, 0);arrayName[2] = new Model("C", 2, 4, 4, 0, 0, 0);arrayName[3] = new Model("D", 3, 2, 2, 0, 0, 0);arrayName[4] = new Model("E", 4, 4, 4, 0, 0, 0);for (int i = 0; i < 5; i++) {System.out.println(arrayName[i].getProcessName() + ","+ arrayName[i].getStartTime() + ","+ arrayName[i].getNeedTime() + ","+ arrayName[i].getLeftTime() + ","+ arrayName[i].getFinishTime() + ","+ arrayName[i].getCyclingTime() + ","+ arrayName[i].getQuanTime());System.out.print("\n");// 这也是换⼀⾏}// System.out.println(arrayName[0].getProcessName());// for(int i=0;i<number;i++){//// System.out.println("请输⼊第"+i+"个进程名：");// String processName=in.next();// System.out.println("请输⼊第"+i+"个进程到达时间：");// double starTime=in.nextFloat();//// }int index = 0;int runningTime = 0;int q = 2;Model processArrayName[] = new Model[5];while (arrayName.length > 0) {int i = 0;Model p = new Model();p = arrayName[index];if (p.getStartTime() > runningTime)runningTime = p.getStartTime();if (p.getLeftTime() > q) {System.out.printf(p.getProcessName() + "," + q);System.out.print("\n");// 这也是换⼀⾏runningTime += q;int term = p.getLeftTime();term = term - q;p.setLeftTime(term);} else {System.out.printf(p.getProcessName() + "," + p.getLeftTime());System.out.print("\n");// 这也是换⼀⾏runningTime += p.getLeftTime();p.setLeftTime(0);p.setFinishTime(runningTime);p.setCyclingTime(p.getFinishTime() - p.getStartTime());p.setQuanTime(p.getCyclingTime() / p.getNeedTime());System.out.printf("--" + p.getProcessName() + ","+ p.getStartTime() + "," + p.getNeedTime() + ","+ p.getLeftTime() + "," + p.getFinishTime() + ","+ p.getCyclingTime() + "," + p.getQuanTime());System.out.print("\n");// 这也是换⼀⾏processArrayName[i] = p;for (int j = i; j < arrayName.length - 1; j++) {arrayName[j] = arrayName[j + 1];}// arrayName[arrayName.length - 1] = null;num--;}index += 1;if (index > arrayName.length || index == arrayName.length) {index = 0;}i++;}}}2.FCFS算法2. 1算法思想：先来先服务算法按照作业进⼊系统后备作业对列的先后次序来挑选作业，先进⼊系统的作业将优先被挑选进⼊内存，创建⽤户进程，分配所需资源，然后移⼊就绪队列。

实验一CPU调度一、实验内容选择一个调度算法，实现处理机调度。

二、实验目的多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机。

本实验模拟实现处理机调度，以加深了解处理机调度的工作。

三、实验题目1、设计一个按优先权调度算法实现处理机调度的程序；2、设计按时间片轮转实现处理机调度的程序。

四、实验要求PCB内容：进程名/PID；要求运行时间（单位时间）；优先权；状态：PCB指针；1、可随机输入若干进程，并按优先权排序；2、从就绪队首选进程运行：优先权-1/要求运行时间-1要求运行时间=0时，撤销该进程3、重新排序，进行下轮调度；4、最好采用图形界面；5、可随时增加进程；6、规定道数，设置后备队列和挂起状态。

若内存中进程少于规定道数，可自动从后备队列调度一作业进入。

被挂起进程入挂起队列，设置解挂功能用于将指定挂起进程解挂入就绪队列。

7、每次调度后，显示各进程状态。

五、实验源码/*** @(#)CPUScheduling.java*** @author Liang Jiabin* @version 1.00 2010/11/5*/import java.awt.*;import javax.swing.*;import java.awt.event.ActionListener;import java.awt.event.ActionEvent;import java.util.Vector;public class CPUScheduling extends Thread{private JFrame frame;private JScrollPane reserveSp,waitingSp,finishSp;private JList reserveList, readyList, waitingList, finishList;private DefaultListModel reserveLm, readyLm, waitingLm, finishLm;private JLabel reserveLbl, readyLbl, CPULbl, waitingLbl, finishLbl;private JTextField CPUTf;private JLabel needTimeLbl, priorityLbl;private JComboBox needTimeCb, priorityCb;private JButton newBtn, suspendBtn, unsuspendBtn, exitBtn;private JLabel rToRLbl,rToCPULbl,CPUToRLbl,CPUToWLbl,wToRLbl;private JLabel CPUToFLbl,warningLbl, explainLbl;private int number = 1; //进程名序号private String CPUProcess = "";private String CPUProcessId = "";private String CPUProcessPriority = "0"; private String CPUProcessTime = "0";private String maxPriorityProcess = "";private String maxPriorityProcessId = ""; private String maxPriorityProcessTime = ""; private String maxPriorityProcessPriority = "0";private Vector waitingReadyV = new Vector(1,1);public CPUScheduling(){frame = new JFrame("CPU Scheduling");Container c = frame.getContentPane();c.setBackground(Color.pink);c.setLayout(null);reserveLbl = new JLabel("后备队列");reserveLbl.setBounds(50,20,60,30);c.add(reserveLbl);reserveLm = new DefaultListModel(); reserveList = new JList(reserveLm);reserveSp = new JScrollPane(reserveList); reserveSp.setBounds(30,50,100,200);c.add(reserveSp);rToRLbl = new JLabel(">>>>>"); rToRLbl.setBounds(145,100,60,30);c.add(rToRLbl);readyLbl = new JLabel("就绪队列"); readyLbl.setBounds(220,20,60,30);c.add(readyLbl);readyLm = new DefaultListModel(); readyList = new JList(readyLm); readyList.setFixedCellHeight(30); readyList.setBounds(200,50,100,200);c.add(readyList);rToCPULbl = new JLabel(">>>>>"); rToCPULbl.setBounds(320,50,50,30);c.add(rToCPULbl);CPUToRLbl = new JLabel("<<<<<"); CPUToRLbl.setBounds(320,65,50,30);c.add(CPUToRLbl);CPULbl = new JLabel("CPU"); CPULbl.setBounds(410,20,50,30);c.add(CPULbl);CPUTf = new JTextField(20); CPUTf.setEditable(false);CPUTf.setBounds(370,55,100,30);c.add(CPUTf);CPUToWLbl = new JLabel("||"); CPUToWLbl.setBounds(415,80,20,50);c.add(CPUToWLbl);wToRLbl = new JLabel("<<<<<"); wToRLbl.setBounds(320,160,50,30);c.add(wToRLbl);waitingLbl = new JLabel("挂起队列"); waitingLbl.setBounds(390,110,60,30);c.add(waitingLbl);waitingLm = new DefaultListModel(); waitingList = new JList(waitingLm);waitingSp = new JScrollPane(waitingList); waitingSp.setBounds(370,140,100,200); c.add(waitingSp);CPUToFLbl = new JLabel(">>>>>"); CPUToFLbl.setBounds(480,55,50,30);c.add(CPUToFLbl);finishLbl = new JLabel("完成队列"); finishLbl.setBounds(560,20,60,30);c.add(finishLbl);finishLm = new DefaultListModel();finishList = new JList(finishLm);finishSp = new JScrollPane(finishList);finishSp.setBounds(540,50,100,200);c.add(finishSp);needTimeLbl = new JLabel("要求运行时间"); needTimeLbl.setBounds(10,330,100,30);c.add(needTimeLbl);String[] time = {"1","2","3","4","5","6","7","8","9"}; needTimeCb = new JComboBox(time); needTimeCb.setEditable(true);needTimeCb.setBounds(95,330,60,30);c.add(needTimeCb);priorityLbl = new JLabel("优先权");priorityLbl.setBounds(175,330,50,30);c.add(priorityLbl);String[] priority = {"1","2","3","4","5","6","7","8","9"}; priorityCb = new JComboBox(priority);priorityCb.setBounds(220,330,60,30);c.add(priorityCb);newBtn = new JButton("增加");newBtn.setBounds(120,380,60,30);c.add(newBtn);warningLbl = new JLabel();warningLbl.setForeground(Color.RED);warningLbl.setBounds(360,350,200,30);c.add(warningLbl);suspendBtn = new JButton("挂起");suspendBtn.setBounds(340,380,60,30);c.add(suspendBtn);unsuspendBtn = new JButton("解挂");unsuspendBtn.setBounds(440,380,60,30);c.add(unsuspendBtn);exitBtn = new JButton("退出");exitBtn.setBounds(560,380,60,30);c.add(exitBtn);explainLbl = new JLabel("注：进程信息表示为“进程名，需要运行时间，优先权”");explainLbl.setBounds(10,420,500,30);c.add(explainLbl);//Button事件注册ButtonListener btnListener = new ButtonListener();newBtn.addActionListener(btnListener);suspendBtn.addActionListener(btnListener);unsuspendBtn.addActionListener(btnListener);exitBtn.addActionListener(btnListener);//调度器线程开启this.start();frame.setSize(720,520);frame.setVisible(true);frame.setLocationRelativeTo(null);frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}/** 开启线程*/public synchronized void run(){try{while (true){//判断waiting队列是否有进程在等待进ready队列while (readyLm.size()<4 && waitingReadyV.size() != 0){String s = waitingReadyV.get(0).toString();readyLm.addElement(s);wToRLbl.setForeground(Color.RED);this.sleep(500);wToRLbl.setForeground(Color.BLACK);waitingReadyV.remove(0);waitingLm.removeElement(s);}//判断后备队列进程能否进就绪队列while (readyLm.size()<4 && !reserveLm.isEmpty()){readyLm.addElement(reserveLm.getElementAt(0));rToRLbl.setForeground(Color.RED);this.sleep(500);rToRLbl.setForeground(Color.BLACK);reserveLm.removeElementAt(0);}//对就绪队列中的进程按优先级排序，找出优先级最大的进入CPU运行if (!readyLm.isEmpty()){String[] s;int index = -1;for (int i=readyLm.size()-1; i>=0; i--){s = readyLm.getElementAt(i).toString().split(",");if (Integer.parseInt(s[2]) >= Integer.parseInt(CPUProcessPriority)){maxPriorityProcess = readyLm.getElementAt(i).toString();maxPriorityProcessId = s[0];maxPriorityProcessTime = s[1];maxPriorityProcessPriority = s[2];index = i;CPUProcessPriority = maxPriorityProcessPriority;}}if (!maxPriorityProcessId.equals(CPUProcessId)){CPUProcess = maxPriorityProcess;CPUProcessId = maxPriorityProcessId;CPUProcessTime = maxPriorityProcessTime;CPUProcessPriority = maxPriorityProcessPriority;}rToCPULbl.setForeground(Color.RED);CPUTf.setText(CPUProcessId);this.sleep(500);readyLm.removeElement(CPUProcess);rToCPULbl.setForeground(Color.BLACK);}this.sleep(1000); //在CPU上运行一秒//时间片到了，CPU上的进程转到就绪队列或完成队列if (!CPUTf.getText().equals("")){CPUTf.setText("");int time = Integer.parseInt(CPUProcessTime);CPUProcessTime = String.valueOf(--time);if (Integer.parseInt(CPUProcessPriority) > 1) //若优先级不为1则减1{int priority = Integer.parseInt(CPUProcessPriority);CPUProcessPriority = String.valueOf(--priority);}if (Integer.parseInt(CPUProcessTime) != 0) //要求运行时间不为0则进入ready队列{CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;readyLm.addElement(CPUProcess);CPUToRLbl.setForeground(Color.RED);this.sleep(500);CPUTf.setText("");CPUToRLbl.setForeground(Color.BLACK);}else //要求运行时间为0则转到完成队列{CPUToFLbl.setForeground(Color.RED);CPUProcessTime = String.valueOf(0);CPUProcessPriority = String.valueOf(0);CPUProcess = CPUProcessId + "," + CPUProcessTime + "," + CPUProcessPriority;finishLm.addElement(CPUProcess);CPUProcessId = "";this.sleep(500);CPUToFLbl.setForeground(Color.BLACK);}}}}catch (Exception e){e.printStackTrace();}}/** 按钮监听器*/class ButtonListener implements ActionListener{public synchronized void actionPerformed(ActionEvent ae) {JButton source = (JButton)ae.getSource();if (source == newBtn) //增加进程{String time = "1";time = needTimeCb.getSelectedItem().toString();String priority = "1";priority = priorityCb.getSelectedItem().toString();String pid = String.valueOf(number);String reserveItem = "";reserveItem = "P" + pid + "," + time + "," + priority;reserveLm.addElement(reserveItem);number++;}else if (source == suspendBtn) //挂起进程{System.out.println("点击挂起" ); /////if (!CPUTf.getText().equals("")){CPUToWLbl.setForeground(Color.RED);CPUTf.setText("");CPUProcessId = "";waitingLm.addElement(CPUProcess);System.out.println("挂起成功" ); /////try{sleep(500);}catch (Exception e){}CPUToWLbl.setForeground(Color.BLACK);}}else if (source == unsuspendBtn) //解挂进程{System.out.println("点击解挂" ); /////String unsuspendProcess = "";if (waitingList.getSelectedValue()!= null){unsuspendProcess = waitingList.getSelectedValue().toString();waitingReadyV.add(unsuspendProcess);warningLbl.setText("");System.out.println("解挂成功" ); /////}else{warningLbl.setText("请选要择解挂的进程");}}else if (source == exitBtn) //退出程序{System.exit(0);}}}/** main函数*/public static void main(String args[]){new CPUScheduling();}}六、实验结果。

操作系统实验报告时间片轮转调度算法“网络协议分析”实验4实验名称：用Ethereal研究DNS和HTTP协议实验目的：通过对捕获分组的分析和研究，加深对DNS协议和HTTP协议的工作原理和实现过程的理解。

实验环境：连网PC机，Ethereal网络协议分析软件实验步骤：1．安装Ethereal网络协议分析器。

2．打开Ethereal软件菜单中的Help->Contents，可学习Ethereal的使用方法。

3．开始捕获分组之前，清空客户端Web浏览器的高速缓存和DNS的高速缓存（命令为：ipconfig /flushdns）。

（想一想，为什么？）4．在Capture->Option里选择网卡类型；取消捕获分组的“混杂模式”；设置捕获过滤器为：“host 本机IP”，这样Ethereal就会只捕获从本机发出的和发往本机的分组。

5．点击Start启动协议分析器，用Ethereal捕获从本机发出和发往本机的分组。

6．在Web浏览器中输入URL（如.cn, 等，网页较简单）。

网页显示出来后，过一会儿停止捕获。

将跟踪文件保存在一个文件中。

实验结果分析：1．在跟踪列表框中找出请求网页时发出的DNS查询报文和回答报文，找出发起TCP连接的三次握手报文，找出HTTP请求报文和响应报文。

2．在协议框中找出各层协议，观察各层协议，并对照教材中DNS查询/回答报文结构和HTTP请求/响应报文结构对这些应用层报文进行分析，找出报文中各字段相应的内容，解释其含义和用途。

3．你的主机所用的DNS服务器的IP地址是多少？你的浏览器与DNS服务器之间使用传输层的什么协议进行通信？202.196.0.1DNS请求报文和应答报文的ID号一样吗？是什么？一样，0xc4a6你所请求网站的规范名是什么？mail.DNS服务器对你的域名解析请求在应答中给出了几个可用的IP地址？都是什么？2个，202.196.0.16，202.196.0.17和DNS服务器通信时，你的客户机使用的端口号是多少？DNS服务器使用的端口号是多少？64384，53你所请求Web服务器的IP地址是什么？其域名有几个层次（参看教材127页）？202.196.0.16 4个如果请求一个存在/不存在的网页，Web服务器分别会应答什么？ ??等等。

实习一处理器调度一.实习内容选择一个调度算法，实现处理器调度。

二.实习目的本实习模拟在单处理器环境下的处理器调度，加深了解处理器调度的工作。

三.实习题目设计一个按优先数调度算法实现处理器调度的程序。

四. 设计思想1.设计思路(1)假定系统有5个进程，每个进程用一个PCB来代表。

(2) 开始运行之前，为每个进程确定它的“优先数”和“要求运行时间”。

通过键盘输入这些参数。

(3) 按进程优先数排列进程，优先数最大的进程插入队首，否者比较进程优先数，插入适当位置。

(4) 处理器总是选择队首进程运行。

采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。

(5) 进程运行一次后，若要求运行时间不等于0，则将它加入就绪队列，否则，将状态改为“结束”，退出就绪队列。

(6) 若就绪队列为空，结束，否则转到(4)重复。

2.主要数据结构struct pcb { /* 定义进程控制块PCB */char name[10]; /*进程名*/char state; /*状态*/int super; /*优先数*/int ntime; /*要求运行时间*/int rtime; /*周转时间*/struct pcb* link; /*下一个进程pcb首地址*/}3.主要代码结构及代码段分析void input() /* 建立进程控制块函数*/{ int i,num;system("cls"); /*清屏*/for(i=1;i<=5;i++){ printf("\n projectNo.%d:\n",i);p=getpch(PCB);printf("\n please input project name:");scanf("%s",p->name);printf("\n please input project priority:");scanf("%d",&p->super);printf("\n please input project running time:");scanf("%d",&p->ntime);printf("\n");p->rtime=0;p->state='W';p->link=NULL;sort(); /* 调用sort函数*/}}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;}}int space()/*求队列长度*/{int l=0;PCB* pr=ready;while(pr!=NULL){ l++;pr=pr->link;}return(l);}void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/{printf("\n proname\t state\t\t priority\t needtime\t remaintime\n"); printf("| %s\t\t",pr->name);printf("| %c\t\t",pr->state);printf("| %d\t\t",pr->super);printf("| %d\t\t",pr->ntime);printf("| %d\t\t",pr->rtime);printf("\n");}void check() /* 建立进程查看函数 */{PCB* pr;printf("\n **** the running project is:\n"); /*显示当前运行进程*/disp(p);pr=ready;printf("\n **** the ready project state is:\n"); /*显示就绪队列状态*/ while(pr!=NULL){disp(pr);pr=pr->link;}}void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/{ printf("\n project[%s] has finished.\n",p->name);free(p);}void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/{ (p->rtime)++;if(p->rtime==p->ntime){ p->state='E';printf("\n **** the finished project is:\n");disp(p);destroy();} /* 调用destroy函数*/else{(p->super)--;p->state='W';sort(); /*调用sort函数*/}}void main() /*主函数*/{int len,h=0;char ch;input();len=space();while((len!=0)&&(ready!=NULL)){ch=getchar();h++;printf("-----------------------------------------------------"); printf("\n now is %d rounds. \n",h);p=ready;ready=p->link;p->link=NULL;p->state='R';check();running();printf("\n press any key to continue......\n");}printf("\n\n all projects have finished.\n");getch();/*从键盘获得字符*/}五.上机实习所用平台及相关软件本程序在windows xp平台下，TC2.0编译器编译通过。

处理器调度算法实验报告一、实验目的本次实验的目的是通过模拟处理器调度算法，了解不同调度算法的优缺点，以及如何根据不同场景选择合适的算法。

二、实验环境本次实验使用C++语言编写程序，在Visual Studio 2019环境下进行开发和测试。

三、实验内容1. 实现FIFO调度算法FIFO（First In First Out）调度算法是最简单的一种调度算法，即先进先出。

在这种算法中，作业按照提交顺序排队等待执行。

当CPU空闲时，选择队列中最早提交的作业进行执行。

这种算法没有考虑作业的优先级和执行时间长短等因素，只关注作业的提交时间。

因此，在一些场景下可能会出现长作业占用CPU资源导致短作业等待时间过长等问题。

2. 实现SJF调度算法SJF（Shortest Job First）调度算法是一种非抢占式的短作业优先算法。

在这种算法中，每个作业都有一个估计运行时间，在CPU空闲时选择估计运行时间最短的作业进行执行。

如果两个作业估计运行时间相同，则按照提交顺序进行排队。

这种算法可以有效地减少平均等待时间和平均周转时间，但是可能会导致长作业等待时间过长。

3. 实现优先级调度算法优先级调度算法是一种抢占式的算法，即当高优先级作业到达时可以抢占正在执行的低优先级作业。

在这种算法中，每个作业都有一个优先级，CPU空闲时选择优先级最高的作业进行执行。

这种算法可以根据不同场景设置不同的作业优先级，但是可能会导致低优先级作业等待时间过长。

4. 实现时间片轮转调度算法时间片轮转调度算法是一种抢占式的循环调度算法。

在这种算法中，每个作业被分配一个固定长度的时间片，在该时间片内执行完毕后，如果该作业还未完成，则将其放入队尾等待下一次调度。

这种算法可以有效地保证每个作业都有机会获得CPU资源，并且能够避免长作业占用CPU资源导致短作业等待时间过长。

四、实验结果通过对以上四种调度算法进行模拟实验，得到了以下结果：1. FIFO调度算法：平均等待时间较长，平均周转时间也较长。

实验2 处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三、实验题目按时间片轮转法实现处理器调度的模拟设计与实现[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为Q1，Q2，Q3，Q 4，Q5。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。

当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如，当前轮到P2执行，则有：标志单元K1K2K3K4K5(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实验是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。

在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。

实验一单处理器调度算法的实现班级：计算机04-1班学号： 04034040112姓名：汀芷约成绩：___ ________日期：_ 2006-11-02实验一单处理器调度算法的实现一、实验目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。

为了使系统中的各进程能有条不紊地运行，必须选择某种调度策略，以选择占用处理机。

要求学生设计一个模拟单处理机调度的算法，以巩固和加深处理机调度的概念。

二、实验内容设计一个按时间片轮转法调度的算法。

提示：1、假设系统有5个进程，每个进程用一个进程控制块PCB来代表。

PCB 的格式如图所示。

其中，进程名即是进程标识。

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

按照进程到达的顺序排队。

系统设置一个队头和队尾指针分别指向第一个和最后一个进程。

新生成的进程放队尾。

2、为每个进程任意确定一个要求运行时间和到达时间。

3、按照进程到达的先后顺序排成一个循环队列。

再设一个队首指针指向第一个到达进程的首地址。

4、执行处理机调度时，开始选择队首的第一个进程运行。

另外再设一个当前运行进程指针，指向当前正运行的进程。

5、由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而是执行：一是估计运行时间减1；二是输出当前运行进程的名字。

用这两个操作来模拟进程的一次执行。

6、进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。

同时还应该判断该进程的剩余运行是否为0。

若不为0，则等待下一轮的运行；若该进程的剩余时间为0，则将该进程的状态置为C，并退出循环队列。

7、若就绪队列不空，则重复上述的（5）和（6）步骤直到所有进程都运行为止。

8、在所设计的调度程序中，应包含显示或打印语句。

以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

三、实验说明1、程序中使用的数据结构及符号说明：数据结构：数组data[][]符号说明：每个进程的状态是就绪 W（Wait）、运行R（Run）、或完成C（Complete）三种状态之一。

实验一处理器调度一、实验内容选择一个调度算法，实现处理器调度。

二、实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三、实验题目第二题：设计一个按时间片轮转法实现处理器调度的程序。

[提示]：(1)假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：其中，Q1，Q2，Q3，Q4，Q5。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。

当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如，当前轮到P2执行，则有：标志单元K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4)处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。

在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。

实验一单处理器调度算法的实现班级：计算机04-1班学号： 04034040112姓名：汀芷约成绩：___ ________日期：_ 2006-11-02实验一单处理器调度算法的实现一、实验目的在多道程序或多任务系统中，系统同时处于就绪态的进程有若干个。

为了使系统中的各进程能有条不紊地运行，必须选择某种调度策略，以选择占用处理机。

要求学生设计一个模拟单处理机调度的算法，以巩固和加深处理机调度的概念。

二、实验内容设计一个按时间片轮转法调度的算法。

提示：1、假设系统有5个进程，每个进程用一个进程控制块PCB来代表。

PCB 的格式如图所示。

其中，进程名即是进程标识。

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

按照进程到达的顺序排队。

系统设置一个队头和队尾指针分别指向第一个和最后一个进程。

新生成的进程放队尾。

2、为每个进程任意确定一个要求运行时间和到达时间。

3、按照进程到达的先后顺序排成一个循环队列。

再设一个队首指针指向第一个到达进程的首地址。

4、执行处理机调度时，开始选择队首的第一个进程运行。

另外再设一个当前运行进程指针，指向当前正运行的进程。

5、由于本实验是模拟实验，所以对被选中进程并不实际启动运行，而是执行：一是估计运行时间减1；二是输出当前运行进程的名字。

用这两个操作来模拟进程的一次执行。

6、进程运行一次后，以后的调度则将当前指针依次下移一个位置，指向下一个进程，即调整当前运行指针指向该进程的链接指针所指进程，以指示应运行进程。

同时还应该判断该进程的剩余运行是否为0。

若不为0，则等待下一轮的运行；若该进程的剩余时间为0，则将该进程的状态置为C，并退出循环队列。

7、若就绪队列不空，则重复上述的（5）和（6）步骤直到所有进程都运行为止。

8、在所设计的调度程序中，应包含显示或打印语句。

以便显示或打印每次选中进程的名称及运行一次后队列的变化情况。

三、实验说明1、程序中使用的数据结构及符号说明：数据结构：数组data[][]符号说明：每个进程的状态是就绪 W（Wait）、运行R（Run）、或完成C（Complete）三种状态之一。

组号成绩计算机操作系统课程设计报告题目处理器调度专业：计算机科学与技术班级： 2学号：姓名：指导教师：2016年12月 27日一．设计目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实验模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

二．设计内容选择一个调度算法，实现处理器调度。

按时间片轮转法实现处理器调度的模拟设计与实现[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：进程名指针要求运行时间已运行时间状态其中，进程名——作为进程的标识，假设五个进程的进程名分别为Q1，Q2，Q3，Q4，Q5。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。

当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如，当前轮到P2执行，则有：标志单元1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实验是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。

实验一处理器调度一、实习内容选择一个调度算法，实现处理器调度。

二、实习目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

本实习模拟在单处理器情况下的处理器调度，帮助学生加深了解处理器调度的工作。

三、实习题目本实习有两个题，学生可选择其中的一题做实习。

第二题：设计一个按时间片轮转法实现处理器调度的程序。

[提示]：(1) 假定系统有五个进程，每一个进程用一个进程控制块PCB来代表。

进程控制块的格式为：Q1，Q2，Q3，Q4，Q5。

指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。

要求运行时间——假设进程需要运行的单位时间数。

已运行时间——假设进程已经运行的单位时间数，初始值为“0”。

状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R”表示。

当一个进程运行结束后，它的状态为“结束”，用“E”表示。

(2) 每次运行所设计的处理器调度程序前，为每个进程任意确定它的“要求运行时间”。

(3) 把五个进程按顺序排成循环队列，用指针指出队列连接情况。

另用一标志单元记录轮到运行的进程。

例如，当前轮到P2执行，则有：标志单元，K1K2K3K4K5PCB1 PCB2 PCB3 PCB4 PCB5(4) 处理器调度总是选择标志单元指示的进程运行。

由于本实习是模拟处理器调度的功能，所以，对被选中的进程并不实际的启动运行，而是执行：已运行时间+1来模拟进程的一次运行，表示进程已经运行过一个单位的时间。

请同学注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理器运行，直到出现等待事件或运行满一个时间片。

在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。

(5) 进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。