有关高优先权优先的实验

合集下载

操作系统 实验 进程调度 银行家算法 多线程编程 存储管理 磁盘调度

操作系统 实验 进程调度 银行家算法 多线程编程  存储管理 磁盘调度

实验一进程调度实验学时:2学时实验类型:设计实验要求:必修一、实验目的多道程序设计中,经常是若干个进程同时处于就绪状态,必须依照某种策略来决定那个进程优先占有处理机。

因而引起进程调度。

本实验模拟在单处理机情况下的处理机调度问题,加深对进程调度的理解。

二、实验内容1.优先权法、轮转法简化假设1)进程为计算型的(无I/O)2)进程状态:ready、running、finish3)进程需要的CPU时间以时间片为单位确定2.算法描述1)优先权法——动态优先权当前运行进程用完时间片后,其优先权减去一个常数。

2)轮转法三、流程图四、实验程序代码package进程调度;/***@author**/public class CPCB {private String name;private int time;private int count;public int getCount() {return count;}public void setCount(int count) { this.count = count;}public String getName() {return name;}public void setName(String name) { = name;}public int getTime() {return time;}public void setTime(int time) {this.time = time;}}package进程调度;/***@author**/class PCB{private String name;private int time ;private int priority ;public int getTime(){return time;}public void setTime(int time){this.time = time;}public int getPriority(){return priority;}public void setPriority(int priority){ this.priority = priority;}public String getName() {return name;}public void setName(String name) { = name;}}package进程调度;import java.util.LinkedList;/***@author**/class process{private final static int nap_time = 500;private LinkedList<PCB> queue = new LinkedList<PCB>();private LinkedList<CPCB> cqueue = new LinkedList<CPCB>();//优先权算法public void go(int p_Num) throws Exception{for(int i = 0;i<p_Num;i++){PCB pcb = new PCB();int time = (int)(Math.random()*20+1);int pri = (int)(Math.random()*20+4);pcb.setName("进程"+i);pcb.setTime(time);pcb.setPriority(pri);queue.add(pcb);}queue = this.sort(queue);int i=0;while(queue.size()!=0){PCB pcb = (PCB)queue.getFirst();System.out.println(i+"\t\t"+pcb.getName()+"运行\t"+"优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());// Thread.sleep(nap_time);int pre = pcb.getPriority() - 3;int time = pcb.getTime() - 1;if(time<=0){System.out.println(pcb.getName()+"\t\t进程运行结束");PCB p = (PCB)queue.removeFirst();System.out.println("移除队列的进程是\t\t"+p.getName()+"\n队列中还有"+queue.size()+"个进程\n");}else{queue.remove();pcb.setPriority(pre);pcb.setTime(time);// System.out.println("运行后:"+i+"----"+pcb.getName()+"---优先级:"+pcb.getPriority()+"---所需时间:"+pcb.getTime());queue.add(pcb);queue = this.sort(queue);}i++;}}//时间片轮转调度算法public void cycle(int p_Num) throws Exception{final int time = 3; //定义轮转时间片数for(int i = 0;i<p_Num;i++){CPCB cpcb = new CPCB();cpcb.setTime((int)(Math.random()*20)+1);cpcb.setName("进程"+i);cpcb.setCount(0);cqueue.add(cpcb);}while(cqueue.size()!=0){CPCB cpcb = (CPCB)cqueue.getFirst();while(cpcb.getCount()!=time){// Thread.sleep(nap_time);cpcb.setTime(cpcb.getTime() - 1);cpcb.setCount(cpcb.getCount()+1);for(int i=0;i<cqueue.size();i++)//输出进程运行情况{CPCB cpcb1 = (CPCB)cqueue.get(i);System.out.println(cpcb1.getName()+"\t\t所需时间片数"+cpcb1.getTime()+"\t\t已占用CPU时间片数"+cpcb1.getCount());}if(cpcb.getTime()==0){System.out.println(cpcb.getName()+"运行结束\n"+"-------------移除队列的是"+cpcb.getName()+"-------------");cqueue.removeFirst();System.out.println("-------------队列中还有"+cqueue.size()+"个进程--------------");break;}if(cpcb.getCount()==time){// cqueue.remove();System.out.println("----因为"+cpcb.getName()+"占用CPU时间片数"+cpcb.getCount()+"="+time);System.out.println(cpcb.getName()+"时间片运行结束"+cpcb.getCount()+cpcb.getTime());CPCB p = (CPCB)cqueue.removeFirst();cqueue.add(p);cpcb.setCount(0);break;}}}}public LinkedList<PCB> sort(LinkedList<PCB> processes){for(int i=0;i<processes.size();i++){PCB thread = new PCB();thread = processes.get(i);for(int j=i+1;j<processes.size();j++){if(thread.getPriority() < processes.get(j).getPriority()){PCB mythread = new PCB();mythread = thread;//thread = processes.get(j);processes.set(i, processes.get(j));processes.set(j, mythread);}}}return processes;}}package 进程调度;import java.io.BufferedReader;import java.io.InputStreamReader;/**** @author 邱福文**/public class MainFun{public void FPF(){}public static void main (String[] args) throws Exception{Integer n2;do{System.out.print("请输入进程数:");BufferedReader sin = new BufferedReader(new InputStreamReader(System.in));String str = sin.readLine();Integer n = Integer.parseInt(str);System.out.print("请输入调度算法:\n"+"1为优先权\n"+"2为轮转法\n"+"0 退出\n");BufferedReader sin2 = new BufferedReader(new InputStreamReader(System.in));String str2 = sin2.readLine();process p = new process();// do{n2 = Integer.parseInt(str2);switch(n2){case 0:break;case 1:p.go(n);break;case 2:p.cycle(n);break;default:System.out.print("输入有误请重新输入");break;}}while(n2!=0);}}五、实验结果请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出10 进程0运行优先级:19---所需时间:181 进程1运行优先级:19---所需时间:152 进程0运行优先级:16---所需时间:173 进程1运行优先级:16---所需时间:144 进程0运行优先级:13---所需时间:165 进程1运行优先级:13---所需时间:136 进程2运行优先级:10---所需时间:87 进程0运行优先级:10---所需时间:158 进程1运行优先级:10---所需时间:129 进程2运行优先级:7---所需时间:710 进程0运行优先级:7---所需时间:1411 进程1运行优先级:7---所需时间:1112 进程2运行优先级:4---所需时间:613 进程0运行优先级:4---所需时间:1314 进程1运行优先级:4---所需时间:1015 进程2运行优先级:1---所需时间:516 进程0运行优先级:1---所需时间:1217 进程1运行优先级:1---所需时间:918 进程2运行优先级:-2---所需时间:419 进程0运行优先级:-2---所需时间:1120 进程1运行优先级:-2---所需时间:821 进程2运行优先级:-5---所需时间:322 进程0运行优先级:-5---所需时间:1023 进程1运行优先级:-5---所需时间:724 进程2运行优先级:-8---所需时间:225 进程0运行优先级:-8---所需时间:926 进程1运行优先级:-8---所需时间:627 进程2运行优先级:-11---所需时间:1 进程2 进程运行结束移除队列的进程是进程2队列中还有2个进程28 进程0运行优先级:-11---所需时间:829 进程1运行优先级:-11---所需时间:530 进程0运行优先级:-14---所需时间:731 进程1运行优先级:-14---所需时间:432 进程0运行优先级:-17---所需时间:633 进程1运行优先级:-17---所需时间:334 进程0运行优先级:-20---所需时间:535 进程1运行优先级:-20---所需时间:236 进程0运行优先级:-23---所需时间:437 进程1运行优先级:-23---所需时间:1 进程1 进程运行结束移除队列的进程是进程1队列中还有1个进程38 进程0运行优先级:-26---所需时间:339 进程0运行优先级:-29---所需时间:240 进程0运行优先级:-32---所需时间:1进程0 进程运行结束移除队列的进程是进程0队列中还有0个进程请输入进程数:3请输入调度算法:1为优先权2为轮转法0 退出2进程0 所需时间片数8 已占用CPU时间片数1 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数7 已占用CPU时间片数2 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数3 进程1 所需时间片数6 已占用CPU时间片数0 进程2 所需时间片数13 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束36进程1 所需时间片数5 已占用CPU时间片数1 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数4 已占用CPU时间片数2 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数3 进程2 所需时间片数13 已占用CPU时间片数0 进程0 所需时间片数6 已占用CPU时间片数0 ----因为进程1占用CPU时间片数3=3进程1时间片运行结束33进程2 所需时间片数12 已占用CPU时间片数1 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数11 已占用CPU时间片数2 进程0 所需时间片数6 已占用CPU时间片数0 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数3 进程0 所需时间片数6 已占用CPU时间片数0----因为进程2占用CPU时间片数3=3进程2时间片运行结束310进程0 所需时间片数5 已占用CPU时间片数1 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数4 已占用CPU时间片数2 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数3 进程1 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数10 已占用CPU时间片数0 ----因为进程0占用CPU时间片数3=3进程0时间片运行结束33进程1 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数10 已占用CPU时间片数0 进程0 所需时间片数3 已占用CPU时间片数0 进程1运行结束-------------移除队列的是进程1--------------------------队列中还有2个进程--------------进程2 所需时间片数9 已占用CPU时间片数1 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数8 已占用CPU时间片数2 进程0 所需时间片数3 已占用CPU时间片数0 进程2 所需时间片数7 已占用CPU时间片数3 进程0 所需时间片数3 已占用CPU时间片数0 ----因为进程2占用CPU时间片数3=3进程2时间片运行结束37进程0 所需时间片数2 已占用CPU时间片数1 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数1 已占用CPU时间片数2 进程2 所需时间片数7 已占用CPU时间片数0 进程0 所需时间片数0 已占用CPU时间片数3 进程2 所需时间片数7 已占用CPU时间片数0 进程0运行结束-------------移除队列的是进程0--------------------------队列中还有1个进程--------------进程2 所需时间片数6 已占用CPU时间片数1进程2 所需时间片数4 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束34进程2 所需时间片数3 已占用CPU时间片数1进程2 所需时间片数2 已占用CPU时间片数2进程2 所需时间片数1 已占用CPU时间片数3----因为进程2占用CPU时间片数3=3进程2时间片运行结束31进程2 所需时间片数0 已占用CPU时间片数1进程2运行结束-------------移除队列的是进程2--------------------------队列中还有0个进程--------------请输入进程数:实验二银行家算法一、实验目的死锁会引起计算机工作僵死,因此操作系统中必须防止。

操作系统进程调度模拟(全三分合集)

操作系统进程调度模拟(全三分合集)

实验一进程调度实验一、目的要求用高级语言编写和调试一个进程调度程序,以加深对进程的概念及进程调度算法的理解。

二、例题:设计一个有 N个进程共行的进程调度程序进程调度算法:采用最高优先数优先的调度算法(即把处理机分配给优先数最高的进程)和先来先服务算法。

每个进程有一个进程控制块(PCB)表示。

进程控制块可以包含如下信息:进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。

进程的优先数及需要的运行时间可以事先人为地指定(也可以由随机数产生)。

进程的到达时间为进程输入的时间。

进程的运行时间以时间片为单位进行计算。

每个进程的状态可以是就绪 W(Wait)、运行R(Run)、或完成F(Finish)三种状态之一。

就绪进程获得CPU后都只能运行一个时间片。

用已占用CPU时间加1来表示。

如果运行一个时间片后,进程的已占用 CPU时间已达到所需要的运行时间,则撤消该进程,如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间,也就是进程还需要继续运行,此时应将进程的优先数减1(即降低一级),然后把它插入就绪队列等待CPU。

每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的PCB,以便进行检查。

重复以上过程,直到所要进程都完成为止。

调度算法的流程图如下图所示。

三.实验题:1、编写并调试一个模拟的进程调度程序,采用“最高优先数优先”调度算法对五个进程进行调度。

“最高优先数优先”调度算法的基本思想是把CPU分配给就绪队列中优先数最高的进程。

静态优先数是在创建进程时确定的,并在整个进程运行期间不再改变。

动态优先数是指进程的优先数在创建进程时可以给定一个初始值,并且可以按一定原则修改优先数。

例如:在进程获得一次CPU后就将其优先数减少1。

或者,进程等待的时间超过某一时限时增加其优先数的值,等等。

2、编写并调试一个模拟的进程调度程序,采用“轮转法”调度算法对五个进程进行调度。

轮转法可以是简单轮转法、可变时间片轮转法,或多队列轮转法。

动态高优先权实验报告

动态高优先权实验报告

实验一动态高优先权调度实验一、实验目的:通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解.提高自己的动手能力主要是通过自己去思考并自己的编码更进一步及更贴切的去理解弄明白动态优先权算法的模拟加深对进程概念和进程调度过程的工作流程及其原理!二.实验要求:1.在开是页面用户需要输入作业名,优先权级数,作业要求服务时间;2.每运行一个时间单位,作业的优先权级数减去自己的学号的后两位31mod5=1;3.在运行出的用户界面中需显示初始作业名,作业状态,优先权级数,需要服务的时间,已经运行的时间;4.每次调度前后显示作业队列。

三.实验内容利用C语言或JAVA或其它的语言(我用的用C语言)来实现对N 个进程采用动态优先权优先算法的进程调度。

每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:进程标识数ID进程优先数,并规定优先数越大的进程,其优先权越高进程已占用的CPU时间CUPTIME 进程还需占用的CPU时间ALLTIME。

当进程运行完毕时,ALLTIME变为0进程的阻塞时间STARTBLOCK,表示当进程再运行STARTBLOCK个时间片后,进程将进入阻塞状态。

进程被阻塞的时间BLOCKTIME,表示已阻塞的进程再等待BLOCKTIME个时间片后,将转换成就绪状态。

进程状态STATE.队列指针NEXT,用来将 PCB排成队列。

优先数改变的原则:进程在就绪队列中呆一个时间片,优先数增加1。

进程每运行一个时间片,优先数减1。

二、实验感想:在第次试验时,老师建议大家应该开始自己写程序,可以借鉴参考网上的代码,但绝不能单单的COPY网上的程序了,吃饭容易种饭难哈,自己写动态高优先权调度要比从网上写个代码简单修改一下难得多呀。

我自己开始编时摸不着头脑,从哪里下手。

我还是从网上下了个代码,然后认真的独立几遍,主要理解弄明白她的编写思路,好让我有个清晰的思路!然后自己写程序,不过其中碰见的很多的问题。

实验进程调度

实验进程调度

淮海工学院计算机科学系实验报告书课程名:《操作系统原理》题目:实验一进程管理班级:Z软件52学号:2017140595姓名:郭文静1、实验目的与要求进程是操作系统最重要的概念之一,进程调度是操作系统内核的重要功能,本实验要求用C/C++语言编写一个进程调度模拟程序,至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。

通过本实验可加深对进程调度算法的理解。

1、设计有5个进程并发执行的模拟调度程序,每个程序由一个PCB表示。

2、模拟调度程序至少使用最高优先权优先或时间片轮转法两种算法来实现进程调度。

3、程序执行中应能在屏幕上显示出各进程的状态变化,以便于观察调度的整个过程。

2、实验内容或题目2.1优先级算法说明(1)PCB的结构:优先级算法中,设PCB的结构如右图所示,其中各数据项的含义Array如下:Id:进程标识符号,取值1—5。

Prior:优先级,随机产生,范围5—10。

Used:目前已占用的CPU时间数,初值为0;当该进程被调用执行时,每执行一个时间片,Used加1。

Need:进程尚需的CPU时间数,初值表示该进程需要运行的总时间,取值范围为1—5。

并随机产生,每运行一个时间片need减1;need为0则进程结束。

Status:进程状态R(运行),J(就绪),F(完成);初始时都处于就绪状态。

Next:指向就绪队列中下一个进程的PCB的指针。

(2)初始状态及就绪队列组织:5个进程初始都处于就绪状态,进程标识1—5,used初值都为0。

各进程的优先级随机产生,范围1—5。

处于就绪状态的进程,用队列加以组织,队列按优先级由高到低依次排列,队首指针设为head。

(3)调度原则以及运行时间的处理:正在执行的进程每执行一个时间片,其优先级减1(允许优先级为负)。

进程调度将在以下情况发生:当正在运行的程序其优先级小于就绪队列队首进程的优先级时。

程序中进程的运行时间以逻辑时间片为单位。

2.2时间片轮转算法说明(1)PCB的结构(如下图所示):轮转法中,设PCB的结构如右图所示,其中各数据项的含义如下:Span:在某一轮中,分配给先运行进程的时间片数,取值1—3。

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

操作系统编程进程或作业先来先服务、高优先权、按时间片轮转调度算法
标准文档
实用文案
a=i; } } return a;} } } new(int s) /*定义执行进程后相关数据的修改*/ { int i,g=0; for(i=0;i<4;i++) { if(arrayTask[i].Status==0) continue; else { g=1; break; } } if(g==0) /*当处理的是第一个未执行的进程时执行*/ { arrayTask[s].StartTime=arrayTask[s].ArriveTime; arrayTask[s].EndTime=arrayTask[s].RequestTime+arrayTask[s].ArriveTime; arrayTask[s].RunTime=arrayTask[s].RequestTime; arrayTask[s].Status=1; g=2; } if(g==1) /*当处理的不是第一个未执行的进程时执行*/ { arrayTask[s].Status=1; for(i=0;i<4;i++) { if(arrayTask[i].Status==1) d=arrayTask[i].EndTime; } for(i=0;i<4;i++) /*查找最后执行的进程的完成时间*/ { if(arrayTask[i].EndTime>d&&arrayTask[i].Status==1) d=arrayTask[i].EndTime; } if(arrayTask[s].ArriveTime<d) /*判断修改的进程的到达时间是否在前一个执行的进程的完成时间前面 */ arrayTask[s].StartTime=d; else arrayTask[s].StartTime=arrayTask[s].ArriveTime;

外中断优先级实验报告

外中断优先级实验报告

实验三外中断优先级实验一、实验目的:1.理解单片机中断优先级和优先权。

2.用PROTEUS 设计, 仿真基于AT89C51单片机的中断优先级实验。

3.掌握中断编程方法。

单片机主程序控制P0口数码管循环显示0~8;外中断0、外中断1发生时分别在P2口、P1口依次显示0~8。

通过实验可演示高优先级可中断低优先级, 但低优先级的中断请求不能中断高优先级。

二、PROTEUS电路设计:三、实验仪器和设备PC机、PROTEUS软件或W-A-51综合开发学习板四、源程序设计:1.程序ORG 0000HAJMP MAINORG 0003HAJMP ZD0ORG 0013HAJMP ZD1ORG 0030HMAIN:SETB IT0 ;设置边沿触发方式SETB IT1SETB EX0 ;中断0和中断1中断允许SETB EX1SETB PX1 ;设置优先级, 中断1为高优先级CLR PX0SETB EA ;开中断MOV DPTR,#BIAO ;指针指向表的首地址LOOP: ;主程序P0输出, 在LED上循环显示0-8MOV A,#09LOOP1:JZ LOOPDEC APUSH ACCMOVC A,@A+DPTRMOV P0,ALCALL DISPOP ACCLJMP LOOP1ZD0: ;外部中断0, P1输出, 在LED上循环显示0-8 MOV A,#09LOOP2:DEC APUSH ACCMOVC A,@A+DPTRMOV P1,ALCALL DIS0POP ACCJNZ LOOP2RETIZD1: ;外部中断1, P2输出, 在LED上循环显示0-8 MOV A,#09LOOP3:DEC APUSH ACCMOVC A,@A+DPTRMOV P2,ALCALL DIS1POP ACCJNZ LOOP3RETIDIS: ;延时1SMOV R3,#10DEL3:MOV R2,#200DEL2:MOV R1,#125DEL1:NOPNOPDJNZ R1,DEL1DJNZ R2,DEL2DJNZ R3,DEL3RETBIAO: DB 40H,79H,24H,30H,19H,12H,02H,78H,00H ;7段数码管0-8的显示代码END。

动态优先权进程调度算法模拟实验报告

动态优先权进程调度算法模拟实验报告

动态优先权进程调度算法模拟实验报告动态优先权调度算法是一种动态调度算法,根据进程的优先级来决定下一个要执行的进程。

进程的优先级可以根据其紧迫性、重要性和资源需求等因素来确定。

本实验利用模拟算法来模拟动态优先权调度算法,并通过实例来说明该调度算法的工作原理和优缺点。

一、实验目的通过本实验,我们可以了解动态优先权调度算法的工作原理,掌握如何使用模拟算法来模拟进程的调度过程,进一步了解该调度算法的优缺点。

二、实验环境本实验使用C++编程语言来实现动态优先权调度算法的模拟。

编译器使用Dev-C++。

三、实验步骤1.设计进程控制块(PCB)的数据结构,包括进程优先级、进程标识、进程状态等信息。

2.设计模拟算法来模拟动态优先权调度算法。

具体算法如下:a.初始化就绪队列,将所有的进程按照优先级插入到就绪队列中。

b.选择优先级最高的进程执行,并更新该进程的优先级。

c.执行完毕后更新进程的状态,并将其从就绪队列中删除。

d.如果新的进程到达,将其插入到就绪队列中。

3.实现主函数,模拟进程的创建、调度和执行过程。

4.进行多个实例的测试,观察进程的调度顺序和执行结果。

5.总结实验结果,分析动态优先权调度算法的优缺点。

四、实验结果与分析通过多个实例的测试,我们可以观察到动态优先权调度算法的工作过程和效果。

该算法可以根据进程的优先级来确定下一个要执行的进程,从而可以更好地满足不同进程的需求。

同时,动态优先权调度算法可以确保优先级高的进程能够及时得到执行,提高系统的响应速度。

然而,动态优先权调度算法存在一些缺点。

首先,该算法对进程的优先级要求较高,需要合理设置进程的优先级。

如果优先级设置不合理,可能导致优先级高的进程一直占用CPU资源,而优先级低的进程无法得到执行,造成资源浪费。

其次,该算法没有考虑进程的等待时间和执行时间,容易导致饥饿现象的发生,即一些进程无法得到执行。

五、实验总结通过本实验,我们了解了动态优先权调度算法的工作原理和模拟方法。

《2024年带(N,n)抢占优先权的排队系统研究》范文

《2024年带(N,n)抢占优先权的排队系统研究》范文

《带(N,n)抢占优先权的排队系统研究》篇一一、引言排队系统作为运筹学中的一个重要研究领域,广泛应用于电信、计算机、交通等多个领域。

其中,具有抢占优先权的排队系统更是在现实应用中具有重要的价值。

本文将对带(N,n)抢占优先权的排队系统进行研究,通过对系统的特性进行建模和模拟,以探究其运行机制及性能特点。

二、系统概述带(N,n)抢占优先权的排队系统是一种具有特殊性质的排队系统。

在这种系统中,顾客的到达遵循一定的概率分布,每个顾客都有其优先级,当有更高优先级的顾客到达时,当前服务的顾客会被打断并由新到的顾客取而代之。

这里,“N”代表系统的服务台数量,“n”表示同时能服务的最大顾客数。

这种系统的设计能够提高服务质量并保证关键任务及时得到处理。

三、模型建立为了研究带(N,n)抢占优先权的排队系统,我们首先需要建立数学模型。

该模型包括以下几个部分:1. 顾客到达模型:我们假设顾客的到达遵循某种概率分布,如泊松分布或负指数分布等。

2. 服务时间模型:服务时间同样遵循一定的概率分布,如正态分布等。

3. 优先级模型:我们设定每个顾客有一个优先级,并依据此决定服务的先后顺序。

高优先级的顾客会抢占正在接受服务的低优先级顾客。

4. 系统状态模型:我们需要描述系统在不同条件下的状态变化,如等待的顾客数、服务的顾客数等。

四、性能分析通过数学建模和仿真模拟,我们可以对带(N,n)抢占优先权的排队系统的性能进行分析。

主要包括以下几个方面:1. 等待时间:分析顾客在系统中的平均等待时间,包括从进入系统到开始接受服务的时间以及从等待到完成服务的时间。

2. 吞吐量:研究系统的服务能力,即单位时间内能处理的顾客数量。

3. 效率:评估系统的效率,包括服务效率和服务台的利用率等。

4. 稳定性:分析系统的稳定性,即在不同条件下系统的运行状态是否稳定。

五、实验与结果分析为了验证模型的准确性,我们进行了大量的实验和仿真模拟。

通过改变不同的参数(如服务台数量、顾客到达率、服务时间等),我们观察了系统性能的变化。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

高优先权优先调度算法
一、实验目的
进程是操作系统最重要的概念之一,进程调度又是操作系统核心的主要内容。

本实验要求学生独立的用高级语言编写和调试一个简单的进程调度程序。

算法要求使用高优先权优先调度算法。

通过本实验加深理解有关进程控制块、进程队列的概念,并体会和了解优先数和时间片轮转调度算法的具体实施办法
二、实验内容与要求
(1)设计一个有n 个进程(可假定系统有2个进程)并发执行的进程调度程序。

每一个进程用一个进程控制块PCB 来代表。

PCB中应包含下列信息:进程名、进程优先数、进程需要运行的时间、占用CPU的时间及进程的状态等,且可按调度算法的不同而增减。

各进程的优先数或轮转时间片数,以及进程运行需要地时间片数,均由伪随机数发生器产生。

(2)每个进程处于运行R、就绪W和完成F 三种状态之一,假定初始状态都为就绪状态W。

(3)系统能显示或打印各进程状态和参数的变化情况。

三、实验步骤
1、打开计算机,打开应用软件VC。

2、进行编程。

3、测试程序。

4、记录结果。

四、运行结果
1、就绪队列
2、运行过程
3、最终结果
五、实验总结
通过本次实验,我充分了解了进程调度算法中高优先权优先算法的实现过程,进一步加深我对该知识点的认知,让过在实践中亲身接触到了该算法的实现,同时也让我认识到了实践对知识认知的重要性,任何东西只有经得起实践的检验才能得到认可,我们才能真正理解其内涵。

在此,也要感谢老师给予我这次试验的机会。

六、源代码
#include "stdio.h"
#include "stdlib.h"
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
struct pcb { /* 定义进程控制块PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* next;
}*ready=NULL,*p;
typedef struct pcb PCB;
void sort(PCB *a) /* 建立对进程进行优先级排列函数*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((a->super)>(ready->super))) /*优先级最大者,插入队首*/
{
a->next=ready;
ready=a;
}
else /* 进程比较优先级,插入适当的位置中*/
{
first=ready;
second=first->next;
while(second!=NULL)
{
if((a->super)>(second->super))
{ /*若插入进程比当前进程优先数大,插入到当前进程前面*/
a->next=second;
first->next=a;
second=NULL;
insert=1;
}
else /* 插入进程优先数最低,则插入到队尾*/
{
first=first->next;
second=second->next;
}
}
if(insert==0) first->next=a;
}
}
void createpcb() /* 建立进程控制块函数*/
{
int i,num;
printf("*----------------------------------------------------------*\n");
printf("|*****************最高优先权优先调度算法模拟***************|\n");
printf("*----------------------------------------------------------*\n");
printf("\n 请输入进程数目:");
scanf("%d",&num);
for(i=0;i<num;i++)
{
p=getpch(PCB);
printf("\n 输入第%d个进程的名字、优先数及该进程要求服务的时间:",i);
scanf("%s%d%d",p->name,&p->super,&p->ntime);
p->rtime=0; p->state='w';
p->next=NULL;
sort(p);
}
}
void display1() /*建立进程显示函数,用于显示当前进程*/
{
printf("\n进程名状态优先数要求服务的时间已运行时间
\n");
}
void display2(PCB * pr)
{
printf("%3.5s %7c %6d %12d %10d",pr->name,pr->state,pr->sup er,pr->ntime,pr->rtime);
printf("\n");
}
void check() /* 建立进程查看函数 */
{
PCB *pr;
printf("\n------------------------------------------------------");
printf("\n **** 当前正在运行的进程是%s,它的状态如下:",p->name); /*显示当前运行进程*/
display1();
display2(p);
pr=ready;
printf("\n ****当前就绪队列中进程的状态如下:\n"); /*显示就绪队列状态*/
if(pr==NULL) printf(" ****就绪队列为空!");
else
{
display1();
while(pr!=NULL)
{
display2(pr);
pr=pr->next;
}
}
}
void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ {
printf("\n 进程 [%s] 已完成.\n",p->name);
free(p);
}
void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/
{
(p->rtime)++;
if(p->rtime==p->ntime) destroy(); /* 调用destroy函数*/ else
{
(p->super)--;
p->state='w';
sort(p); /*调用sort函数*/
}
}
void main()
{
char ch;
createpcb();
printf("\n 初始时就绪队列的状态如下:");
display1();
p=ready;
while(p!=NULL)
{
display2(p);
p=p->next;
}
printf("\n 开始运行:..............");
while(ready!=NULL)
{
ch=getchar();
p=ready;
ready=p->next;
p->next=NULL;
p->state='R';
check();
running();
printf("\n 按任一键继续......");
ch=getchar();
}
printf("\n 进程已经完成.\n");
}。

相关文档
最新文档