有关高优先权优先的实验

实验一进程调度实验学时：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。

实验三外中断优先级实验一、实验目的: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资源，而优先级低的进程无法得到执行，造成资源浪费。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

请阐述navon(1977年) 的整体优先效应实验的实验目的、实验方法、实验结果以及实验1. 引言1.1 概述本文旨在探讨navon(1977年)的整体优先效应实验。

整体优先效应是指我们在处理视觉信息时，首先以整体形状或结构为基础进行处理，而忽略其组成部分的细节。

过去的研究表明，人们倾向于将注意力集中在物体的整体特征上，并忽略其单个部分。

该实验通过设计特定的任务来测试整体优先效应，并进一步揭示人们对视觉信息处理的偏好和策略。

1.2 文章结构本文共分为五个部分：引言、实验目的、实验方法、实验结果和结论。

引言部分将从概述、文章结构和目的等方面介绍本研究的背景和意义。

接下来，我们将详细说明navon(1977年)整体优先效应实验的目的、方法和结果。

最后，我们将总结并给出对整体优先效应实验意义和启示方面的研究结论。

1.3 目的本文旨在阐述Navon (1977年) 的整体优先效应实验。

具体来说，我们将重点描述该实验的目标、研究背景以及Navon（1977）所提出整体优先效应实验的简介。

整体优先效应实验是为了探索人们在处理视觉信息时对整体形状的优先权及其对个体元素的忽略程度。

通过该实验，我们可以更深入地了解人类视觉加工中的注意机制和认知决策过程，揭示人们对整体信息的处理偏好，并揭示与之相关的神经机制。

详细介绍该实验目的后，我们将进一步描述实验方法、结果以及相应的统计与分析方法，最终给出结论和对整体优先效应实验意义和启示进行研究结论。

2. 实验目的：2.1 研究背景：在认知心理学领域，研究人员对于视觉信息处理如何影响注意力分配和对整体形状的感知一直感兴趣。

过去的研究表明，当我们面对不同大小的形状时，我们有时会更关注整体形状而非个别细节。

这种现象被称为“整体优先效应”。

Navon （1977年）进行了一项经典实验来探究整体优先效应的存在与特点。

2.2 navon(1977年) 的整体优先效应实验简介：Navon在这项实验中使用了特定类型的刺激材料，即大写字母由小写字母构成的“全局-局部”刺激。

使用动态优先权的进程调度算法的模拟实验进程调度算法是操作系统中对进程进行调度的一种策略，动态优先权调度算法是其中一种常用的调度算法。

下面将对动态优先权调度算法进行模拟实验，并对实验结果进行分析。

首先，我们定义进程的属性包括进程编号、到达时间、服务时间、优先权和完成时间等。

动态优先权调度算法的基本思想是根据进程的优先权决定下一个被调度的进程，优先权越高，被调度的机会越大。

实验过程如下：1.创建一个进程队列，用来存放待调度的进程。

2.输入进程的个数，并依次输入每个进程的到达时间、服务时间和优先权。

3.将所有进程按照到达时间进行排序。

4.从排好序的进程队列中选择优先权最高的进程，即优先权最大的进程。

5.通过执行该进程进行模拟，更新进程队列中的进程信息。

6.根据更新后的进程信息，重新选择下一个被调度的进程。

7.重复步骤5和6，直到所有进程执行完毕。

对于每个进程，我们可以记录其等待时间、周转时间和带权周转时间。

等待时间即为该进程在就绪队列中等待的时间，周转时间是指从进程提交到完成的时间，即完成时间减去到达时间，带权周转时间是指每个进程的周转时间除以服务时间，用来评估进程的调度效果。

下面是一个动态优先权调度算法的模拟实验示例：```pythonclass Process:self.id = idself.priority = prioritydef __lt__(self, other):return self.priority < other.prioritydef dynamic_priority_scheduling(processes):queue = []while processes or queue:for process in processes:queue.append(process)processes.remove(process)queue.sort(reverse=True) # 根据进程的优先权进行排序if queue:process = queue.pop(0)for p in queue:if __name__ == '__main__':n = int(input("Enter the number of processes: "))processes = []for i in range(n):priority = int(input("Enter priority for process {}:".format(i+1)))dynamic_priority_scheduling(processes)```以上代码定义了一个Process类来表示进程，并使用动态优先权调度算法对进程进行调度。

1.实验名称：动态优先权调度过程中就绪队列的模拟2.实验要求：采用动态优先权的进程调度算法，用C语言编程模拟调度过程中每个时间片内的就绪队列。

3.实验内容：（1）每个进程控制块PCB用结构描述，包括以下字段：*进程标识符id*进程优先数priority,并规定优先数越大的进程，其优先权越高。

*进程已占用的CPU时间cputime*进程还需占用的CPU时间alltime，当进程运行完毕时，aiitime变为0*进程的阻塞时间startblock,当进程再运行startblock个时间片后，进程将进入阻塞状态*进程被阻塞的时间blocktime,已阻塞的进程再等待blocktime个时间片后，将转换成就绪状态*进程状态state*队列指针next,将PCB排成队列。

2）调度前，系统中有五个进程，它们的初始状态如下：3）进程在就绪队列呆一个时间片,优先数增加1。

4）进程每运行一个时间片，优先数减3。

5）按下面格式显示每个时间片内就绪队列的情况：READY_QUEUE:->id1->id24.任务分析进程控制块用结构体来表示，包含它的各项属性。

建立两个队列：一个就绪队列，一个阻塞队列。

创建一个进程控制块表示当前正在运行的进程。

程序开始运行时，所有进程都在就绪队列中。

当startblock减少到0时，进程进入阻塞队列。

在阻塞队列中的进程，当blocktime减少到0时，转入就绪队列。

在就绪队列中的进程，如果优先级比当前正在执行的进程高，就可以取代当前进程获取时间片。

当前进程如果运行完毕，就绪队列中优先级最高的进程就可以成为新当前进程。

5.程序流程图#include〈iostream〉#include〈string〉usingnamespace std;#define LEN5typedefenum STATE{READYBLOCKEND}STATE;//定义进程控制块typedefstruct PCB{int id;int priority;int cputime;int alltime;int startblock;int blocktime;STATE state;}PCB;//定义队列typedefstruct queue{int si ze;PCB*data[LEN];}Queue;PCB ps[LEN];PCB*cp; //进程最大数量//进程状态//就绪//阻塞//完成//进程标识符//进程优先级//已占用的CPU时间//还需占用的CPu时间//阻塞时间//被阻塞时间//进程状态//队列中进程的数量//进程的指针//进程数组//当前正在运行的进程6.程序清单Queue rQueue,bQueue;//就绪队列和阻塞队列//就绪队列按优先级降序排序(使用了冒泡排序法)void rQueueSort(){ PCB*temp;for(int i=0;i<rQueue.size-1;i++){for(int j=0;j<rQueue.size-1-i;j++){if(rQueue.data[j]-〉priority<rQueue.data[j+1]-〉priority){temp=rQueue.data[j];rQueue.data[j]=rQueue.data[j+1];}}rQueue.dataj+1]=temp;}}//初始化void init(){//给进程赋值for(int i=0;i<LEN;i++){ps[i].id=i;ps[i].state=READY;ps[i].cputime=0;ps[i].alltime=3;ps[i].blocktime=0;ps[i].startblock=T;}ps[0].priority=9;ps[1].priority=38;ps[2].priority=30;ps[3].priority=29;ps[4].priority=0;ps[2].alltime=6;ps[4].alltime=4;ps[0].startblock=2;ps[0].blocktime=3;cp=NULL;//当前进程赋空bQueue.size=0;//阻塞队列没有进程for(int i=0;i<LEN;i++){bQueue.data[i]=NULL;rQueue.data[i]=&ps[i];}rQueue.size=5;//所有进程全部进入就绪队列rQueueSort();//对就绪队列排序}//打印void print(){cout〈〈"\nRUNNINGPROG:";if(cp!=NULL){cout〈〈cp->id;}cout<<"\nREADY_QUEUE:";for(int i=0;i<rQueue.size;i++){cout〈〈"-〉"〈〈rQueue.data[i]-〉id; }cout<<"\nBLOCK_QUEUE:";for(int i=0;i<bQueue.size;i++){cout〈〈"-〉"〈〈bQueue.data[i]-〉id; }cout〈〈"\n"<<endl;cout<<"ID\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].id<<"\t";}cout<<"\nPRI0RITY\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].priority〈〈"\t";}cout<<"\nCPUTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].cputime〈〈"\t";}cout<<"\nALLTIME\t\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].alltime〈〈"\t";}cout<<"\nSTARTBLOCK\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].startblock<<"\t";}cout<<"\nBLOCKTIME\t";for(int i=0;i<LEN;i++){cout〈〈ps[i].blocktime<<"\t";}cout<<"\nSTATE\t\t";for(int i=0;i<LEN;i++){if(ps[i].state==READY){cout<<"READY"<<"\t";}elseif(ps[i].state==BLOCK){cout<<"BLOCK"<<"\t";}elseif(ps[i].state==END){cout〈〈"END"<<"\t";}}cout〈〈endl;}//出队，返回进程指针PCB*pop(Queue*q){PCB*temp;if(q-〉size>0){temp=q-〉data[0];//取出队首进程for(int i=0;i<q-〉size-1;i++){q-〉data[i]=q-〉data[i+1];//其他进程依次向前移动}q->size__;return temp;//返回队首进程}return NULL;}//入队void push(Queue*q,PCB*p){if(q_>size<LEN){q_>data[q_〉size]=p;//将入队的进程放在队尾q_>size++;}return;}//运行进程void run(){if(rQueue.size〉0||bQueue.size〉0){if(cp==NULL){//程序一开始运行时，从就绪队列取出首进程cp=pop(&rQueue);}//当前进程没有结束，但优先级比就绪队列首进程低if(cp_〉alltime〉0&&cp_>priority<rQueue.data[0]_〉priority){}push(&r Queue,c//改变进程状态//从就绪队列取出新的当前进程//修改当前进程的状态 //将当前进程加入阻塞队列 //从就绪队列取出新的当前进程{//当前进程的startblock 为正数时//运行一次减一个时间片//减到0时，修改进程状态//每运行一个时间片//就绪队列中的进程优先级+1//每运行一个时间片//阻塞队列中的进程blocktime-1//将当前进程放入就绪队列 //就绪队列队首进程成为当前进程if (cp-〉alltime==0){cp->state =END ;cp=pop(&rQueue); }//如果当前进程运行结束//startblock 为0,标志着当前进程要进入阻塞状态if (cp —>startblock==0&&cp —>blocktime>0){cp —>state=BLOCK ; push(&bQueue,cp); cp=pop(&rQueue); }elseif (cp —>startblock>0)cp —>st artblock 一; }cp —>alltime ——;if (cp —>alltime==0){cp —>state=END ;for (int i=0;i<rQueue.size;i++){rQueue.data[i]-〉priority++; }for (int i=0;i<bQueue.size;i++){if (bQueue.data[i]-〉blocktime>0){bQueue.data[i]-〉blocktime--; }//当阻塞队列队首进程blocktime 为0时if (bQueue.size 〉0&&bQueue.data[0]-〉blocktime==0){bQueue.data[0]-〉state=READY ;//修改进程状态push(&rQueue,pop(&bQueue));//将阻塞队列首进程取出，放入就绪队列cp —〉priority-=3;//修改当前进程的优先级cp —>cputime++; //当前进程占用CPU 时间片+1 if (cp —>alltime>0){//当前进程还需运行的时间片-1}//每运行一个时间片，就绪队列排一次序rQueueSort();} }//主函数int main(){init();//初始化 print();//打印进程信息 while (1){_sleep(1000);if (rQueue.size==0&&bQueue.size==0){//当两个队列都为空时，结束程序cp-〉state=END ;break ; }run();//运行进程 print();//打印进程信息 }return 0; }7.实验过程记录m 匚:\WINDQWS\system32\cmd.exe程序开始执行，当前进程是优先级最高的1号进程，1号进程的优先级减3、cputime++、执行几次之后，1号进程执行完毕而且优先级也不是最高的了，所以优先级为33的2号进程成为当前进程，开始执行。

实验三动态高优先权优先调度
实验内容：
模拟实现动态高优先权优先（若数值越大优先权越高，每运行一个时间单位优先权-n，若数值越小优先权越高，没运行一个时间单位优先权+n），具体如下：
设置作业体：作业名，作业的到达时间，服务时间，初始优先权，作业状态（W——等待,R ——运行,F——完成），作业间的链接指针
作业初始化：由用户输入作业名、服务时间、初始优先权进行初始化，同时，初始化作业的状态为W。

显示函数：在作业调度前、调度中和调度后进行显示。

排序函数：对就绪状态的作业按照优先权排序。

优先权相同时进入等待队列时间早的作业在前。

注意考虑到达时间
调度函数：每次从等待队列队首调度优先权最高的作业执行，状态变化。

并在执行一个时间单位后优先权变化，服务时间变化，状态变化。

当服务时间为0时，状态变为
F。

删除函数：撤销状态为F的作业。

实验要求：
1、测试数据可以随即输入或从文件中读入。

2、必须要考虑到作业的到达时间
3、最终能够计算每一个作业的周转时间。

进程调度模拟设计——最高响应比优先调度算法实验报告一、实验题目与要求1、实验题目：加深对作业概念的理解。

深入了解批处理系统如何组织作业、管理作业和调度作业。

2、实验要求：编写程序完成批处理系统中的作业调度，要求采用响应比高者优先的作业调度算法。

实现具体包括：首先确定作业控制块的内容和组成方式；然后完成作业调度；最后编写主函数，对所做工作进行测试。

二、总的设计思想及语言环境、工具1、总的设计思想：最高响应比优先法（HRRN）是对FCFS方式和SJF 方式的一种综合平衡。

HRRN 调度策略同时考虑每个作业的等待时间长短和估计需要的执行时间长短，从中选出响应比最高的作业投入执行。

响应比R定义如下： R=(W+T)/T=1+W/T其中T为该作业估计需要的执行时间，W为作业在后备状态队列中的等待时间。

每当要进行作业调度时，系统计算每个作业的响应比，选择其中R最大者投入执行。

这样，即使是长作业，随着它等待时间的增加，W/T也就随着增加，也就有机会获得调度执行。

这种算法是介于FCFS和SJF 之间的一种折中算法。

由于长作业也有机会投入运行，在同一时间内处理的作业数显然要少于SJF 法，从而采用HRRN 方式时其吞吐量将小于采用SJF 法时的吞吐量。

另外，由于每次调度前要计算响应比，系统开销也要相应增加。

2、语言环境：计算机基本配置要求：操作系统：WIN 98/2000/XP/2003 等Windows平台内存：256MB及以上主存64KB（Memory）（以KB为单位分配）开发语言：Visual C++3、工具：Windows平台＋Visual C++三、数据结构与模块说明（功能与框图）作业调度的实现主要有两个问题：一个是如何将系统中的作业组织起来；另一个是如何进行作业调度。

为了将系统中的作业组织起来，需要为每个进入系统的作业建立档案以记录和作业相关的信息，例如，作业名、作业所需资源、作业执行时间、作业进入系统的时间、作业信息在存储器中的位置、指向下一个作业控制块的指针等信息。

实验3 高(动态)优先权优先的进程调度算法模拟实验目的通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。

实验环境装有操作系统Windows XP和开发工具VC++6.0，内存在256M以上的微机；或者：装有Linux(Fedora 7)操作系统和gcc编译器，内存在256M以上的微机。

实验内容用C语言来实现对N个进程采用动态优先权优先算法的进程调度。

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

当进程运行完毕时，NEEDTIME变为0；进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态；进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，进程将转换成就绪状态；进程状态STATE；(READY, RUNNING, BLOCK, FINISH)队列指针NEXT，用来将PCB排成队列。

优先数改变的原则：进程在就绪队列中呆一个时间片，优先数增加1；进程每运行一个时间片，优先数减3。

假设在调度前，系统中有5个进程，它们的初始状态如下：ID01234PRIORITY93830290CPUTIME00000NEEDTIME33634STARTBLOCK2-1-1-1-1BLOCKTIME30000STATE READY READY READY READY READY为了清楚地观察进程的调度过程，程序应将每个时间片内的进程的情况显示出来，参照的具体格式如下：RUNNING PROCESS: $id0READY QUEUE: $id1->$id2BLOCK QUEUE: $id3->$id4FINISH QUEUE: $id0->$id1->$id2->$id3->$id4==================================================================ID PRIORITY CPUTIME NEEDTIME STATE STARTBLOCK BLOCKTIME0 XX XX XX XX XX XX1 XX XX XX XX XX XX2 XX XX XX XX XX XX3 XX XX XX XX XX XX4 XX XX XX XX XX XX====================================================================实验要求将源程序(priority.c)和程序运行结果写入实验报告。

实验3高优先权优先的进程调度算法模拟引言：进程调度算法是操作系统中非常重要的一部分，它能够有效地利用计算机资源，提高系统的运行效率。

高(动态)优先权优先的进程调度算法是一种根据进程的优先权动态地进行进程调度的算法。

它根据进程的优先权来决定进程被调度的顺序，优先权高的进程将优先被调度执行。

本实验旨在模拟高(动态)优先权优先的进程调度算法。

实验目的：1.了解高(动态)优先权优先的进程调度算法的原理。

2.了解高(动态)优先权优先的进程调度算法的特点。

3.掌握高(动态)优先权优先的进程调度算法的实现过程。

4.通过实验模拟的方式加深对高(动态)优先权优先的进程调度算法的理解。

实验内容：1.设计进程调度的数据结构，包括进程的类（包含进程的名称、到达时间、服务时间、优先权、开始时间、完成时间、周转时间等信息）、进程队列等。

2.根据进程的到达时间，将进程按顺序加入到进程队列中。

3.根据高(动态)优先权优先的进程调度算法，根据进程的优先权确定进程的调度顺序。

4.模拟进程调度的过程，计算进程的开始时间、完成时间、周转时间等信息。

5.最终输出每个进程的调度结果。

实验步骤：第一步：设计进程调度的数据结构首先，我们需要设计进程调度的数据结构，包括进程的类和进程队列。

进程的类包含进程的名称、到达时间、服务时间、优先权、开始时间、完成时间、周转时间等信息。

进程队列用于存储待调度的进程。

第二步：加入进程到进程队列中在模拟进程调度的过程中，我们需要按照进程的到达时间将进程按顺序加入到进程队列中。

根据实际需求，可以手动输入进程的信息或者随机生成进程的信息。

第三步：根据优先权确定进程的调度顺序在高(动态)优先权优先的进程调度算法中，进程的调度顺序是根据进程的优先权确定的。

优先权高的进程将优先被调度执行。

因此，我们需要根据进程的优先权对进程队列进行排序。

第四步：模拟进程调度的过程在实验中，我们需要模拟进程调度的过程。

根据调度算法，选择优先权最高的进程进行调度。

stroop效应实验报告引言：Stroop效应，是指当人们被要求念出一系列颜色字体，但字体的颜色与文字内容不一致时，阅读速度和准确性会受到明显影响的一种现象。

这一效应被广泛应用于认知心理学中，作为一种探究脑功能和自动化认知过程的工具。

本实验旨在通过Stroop效应实验来探究颜色信息和语义信息在注意分配中的相互竞争关系。

实验设计：本实验采用随机化设计，测试共20名参与者，男女比例均衡，年龄在20-30岁之间。

参与者需坐在电脑前进行实验，实验过程中心理背景音乐以及其他干扰因素被排除。

实验材料：实验材料主要包括计算机软件、屏幕显示器和实验指令。

软件是根据实验需要编写的程序，用于呈现实验任务和记录参与者数据。

屏幕显示器用于呈现文字和颜色。

实验指令包括详细说明实验任务和要求。

实验任务：参与者需要在实验过程中根据屏幕上呈现的文字的颜色，快速而准确地做出回应。

实验分为两个任务：颜色识别任务和语义识别任务。

在颜色识别任务中，参与者需要念出屏幕上呈现的字体的颜色，并不受文字本身的干扰，尽可能快速地完成。

在语义识别任务中，参与者需要念出屏幕上呈现的字体所表示的字义，而不受文字颜色的影响。

实验过程：实验开始前，参与者被告知实验目的和任务，并签署知情同意书。

实验分为两个阶段，任务顺序随机。

每个阶段包括练习和正式实验两个部分。

参与者需要完成尽可能多的题目，在每个任务的最后，需要录入参与者的反应时间和准确率。

每个参与者完成实验后，被要求填写问卷反馈。

实验结果：根据实验数据，我们对参与者的反应时间和准确率进行统计分析。

整体结果显示，在颜色识别任务中，参与者的平均反应时间为X毫秒，准确率为X%；在语义识别任务中，参与者的平均反应时间为Y毫秒，准确率为Y%。

进一步的数据分析显示，参与者在颜色识别任务中的反应时间明显优于语义识别任务，而在准确率方面表现相对均衡。

讨论：根据实验结果及分析，我们可以得出以下结论：首先，Stroop效应在实验中得到充分验证，参与者在语义识别任务中的表现受到颜色信息的干扰，导致反应时间较长。

实验三进程调度实验目的1、理解有关进程控制块、进程队列的概念。

2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。

实验内容与基本要求1、设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。

2、建立进程就绪队列。

3、编制两种进程调度算法：优先权调度算法P和时间片轮转调度算法R。

实验报告内容1、优先权调度算法和时间片轮转调度算法原理。

2、程序流程图。

3、程序及注释。

4、运行结果以及结论。

1、优先权调度算法和时间片轮转调度算法原理优先权调度算法：当该算法用于作业调度时，系统从后备作业队列中选择若干个优先级最高的，且系统能满足资源要求的作业装入内存运行；当该算法用于进程调度时，将把处理机分配给就绪进程队列中优先级最高的进程投入运行。

分为非抢占式优先级算法和抢占式优先级算法。

时间片轮转调度算法原理：系统将就绪进程按到达的顺序排成一个队列，按FCFS原则，进程调度程序总是选择就绪队列中的第一个进程执行，且只运行一个时间片。

时间用完后，即使此进程并未完成，仍然将处理机分配给下一个就绪的进程，将此进程返回到就绪队列的末尾，等候重新运行。

2、程序流程图。

3、程序及注释#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct node{char name[20]; /*进程的名字*/int prio; /*进程的优先级*/int round; /*分配CPU的时间片*/int cputime; /*CPU执行时间*/int needtime; /*进程执行所需要的时间*/char state; /*进程的状态，W--就绪态，R--执行态，F--完成态*/int count; /*记录执行的次数*/struct node *next; /*链表指针*/}PCB;PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/int num;void GetFirst(); /*从就绪队列取得第一个节点*/void Output(); /*输出队列信息*/void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高*/void InsertTime(PCB *in); /*时间片队列*/void InsertFinish(PCB *in); /*时间片队列*/void PrioCreate(); /*优先级输入函数*/void TimeCreate(); /*时间片输入函数*/void Priority(); /*按照优先级调度*/void RoundRun(); /*时间片轮转调度*/int main(void){char chose;printf("请输入要创建的进程数目:\n");scanf("%d",&num);getchar();printf("输入进程的调度方法：(P/R)\n");scanf("%c",&chose);switch(chose){case 'P':case 'p':PrioCreate();Priority();break;case 'R':case 'r':TimeCreate();RoundRun();break;default:break;}Output();return 0;}void GetFirst() /*取得第一个就绪队列节点*/{run = ready;if(ready!=NULL){run ->state = 'R';ready = ready ->next;run ->next = NULL;}}void Output() /*输出队列信息*/{PCB *p;/*p = ready;*/printf("进程名\t优先级\t时间片\tcpu时间\t需要时间\t进程状态\t计数器\n");p = ready;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime, p->state,p->count);p = p->next;}p = finish;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime, p->state,p->count);p = p->next;}p = run;while(p!=NULL){printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime, p->state,p->count);p = p->next;}}void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低*/{PCB *fst,*nxt;fst = nxt = ready;if(ready == NULL) /*如果队列为空，则为第一个元素*/{in->next = ready;ready = in;}else /*查到合适的位置进行插入*/{if(in ->prio > fst ->prio) /*比第一个还要大(大于等于)，则插入到队头*/{in->next = ready;ready = in;}else{while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/{nxt = fst;fst = fst->next;}if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/{in ->next = fst ->next;fst ->next = in;}else /*插入到队列中*/{nxt = in;in ->next = fst;}}}}void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/ {PCB *fst;fst = ready;if(ready == NULL){in->next = ready;ready = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/ {PCB *fst;fst = finish;if(finish == NULL){in->next = finish;finish = in;}else{while(fst->next != NULL){fst = fst->next;}in ->next = fst ->next;fst ->next = in;}}void PrioCreate() /*优先级调度输入函数*/{PCB *tmp;printf("输入进程名字和进程所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar(); /*吸收回车符号*/scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/tmp ->round = 0;tmp ->count = 0;InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/}}void TimeCreate() /*时间片输入函数*/{PCB *tmp;int i;printf("输入进程名字和进程时间片所需时间：\n");for(i = 0;i < num; i++){if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL){perror("malloc");exit(1);}scanf("%s",tmp->name);getchar();scanf("%d",&(tmp->needtime));tmp ->cputime = 0;tmp ->state ='W';tmp ->prio = 0;tmp ->round = 2; /*假设每个进程所分配的时间片是2*/tmp ->count = 0;InsertTime(tmp);}void Priority() /*按照优先级调度，每次执行一个时间片*/{int flag = 1;GetFirst();while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行*/{Output(); /*输出每次调度过程中各个节点的状态*/while(flag){run->prio -= 0; /*优先级减去三,若设为0则优先级不变*/run->cputime++; /*CPU时间片加一*/run->needtime--;/*进程执行完成的剩余时间减一*/if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/{run ->state = 'F';run->count++; /*进程执行的次数加一*/InsertFinish(run);flag = 0;}else /*将进程状态置为W，入就绪队列*/{run->state = 'W';run->count++; /*进程执行的次数加一*/InsertTime(run);flag = 0;}}flag = 1;GetFirst(); /*继续取就绪队列队头进程进入执行队列*/}}void RoundRun() /*时间片轮转调度算法*/{int flag = 1;GetFirst();while(run != NULL){Output();while(flag){run->count++;run->cputime++;run->needtime--;if(run->needtime == 0) /*进程执行完毕*/{run ->state = 'F';InsertFinish(run);flag = 0;}else if(run->count == run->round)/*时间片用完*/{run->state = 'W';run->count = 0; /*计数器清零，为下次做准备*/InsertTime(run);flag = 0;}}flag = 1;GetFirst();}}4、运行结果以及结论。

《带(N,n)抢占优先权的排队系统研究》篇一一、引言排队系统是现代服务业中常见的一种数学模型，广泛应用于通信网络、计算机系统、医疗设施、交通系统等领域。

其中，带有抢占优先权的排队系统更是体现了服务过程中的动态性和即时性。

本文旨在研究带(N,n)抢占优先权的排队系统，探讨其特性、性能及优化策略。

二、背景与意义在许多服务系统中，客户或任务往往具有不同的优先级。

当高优先级任务到达时，低优先级任务可能被中断或抢占资源以优先处理高优先级任务。

这种带有抢占优先权的排队系统在实际应用中具有广泛意义。

比如，在医疗系统中，紧急患者需要被快速处理，可能中断正在处理的其他患者；在通信网络中，实时传输的媒体数据需要比非实时数据具有更高的处理优先级。

研究这一类排队系统，对于提升系统效率和用户体验至关重要。

三、(N,n)抢占优先权模型描述(N,n)抢占优先权模型指的是在排队系统中，有N个不同优先级的任务或客户类别，且每次仅允许n个高优先级任务抢占资源并立即开始服务。

当高优先级任务数量达到n时，新的高优先级任务必须等待直至有空闲资源或较低优先级任务的释放。

此模型同时考虑了优先级的分配和资源竞争的问题。

四、系统特性分析1. 系统稳定性：在不同到达率和服务率下，分析系统的稳定性条件，即是否会因任务累积而造成系统瘫痪。

2. 性能指标：通过仿真或数学分析方法，研究系统的平均等待时间、平均排队长度等关键性能指标。

3. 优先级策略：探讨不同优先级分配策略对系统性能的影响，包括平等优先、偏重低/高优先级的策略等。

五、优化策略与建议1. 优化资源分配：在有限资源条件下最大化各优先级任务的完成率，确保高优先级任务的及时处理。

2. 动态调整策略：根据系统实时状态（如任务到达率、服务率等）动态调整优先级分配和抢占规则。

3. 引入其他机制：如引入缓冲队列、多级反馈机制等，以缓解资源紧张和优化任务处理顺序。

六、研究展望未来的研究方向可以包括：进一步探索不同模型下(N,n)抢占优先权排队系统的性能特点；考虑其他实际因素如客户满意度、服务质量等对系统设计的影响；开发更加精确的仿真和数学分析工具以指导实际系统的设计和优化等。

抢占式优先级调度算法实验报告一、实验目的1.了解抢占式优先级调度算法的基本原理和实现方法。

2.掌握抢占式优先级调度算法的实现过程。

3.通过实验，加深对操作系统调度算法的理解。

二、实验环境1.操作系统：Windows 102.编程语言：C++三、实验内容1.设计一个简单的抢占式优先级调度算法。

2.编写程序，模拟该算法的实现过程。

3.通过实验，观察和分析该算法的优缺点。

四、实验步骤1.设计抢占式优先级调度算法。

抢占式优先级调度算法是一种基于优先级的调度算法，它的基本思想是将进程按照优先级从高到低排序，然后按照优先级高低依次执行。

如果有更高优先级的进程到来，则当前进程会被抢占，让出CPU资源给更高优先级的进程执行。

2.编写程序，模拟该算法的实现过程。

程序的主要流程如下：（1）定义进程结构体，包括进程ID、进程优先级、进程状态等信息。

（2）定义进程队列，包括就绪队列和阻塞队列。

（3）初始化进程队列，将所有进程按照优先级从高到低排序，放入就绪队列中。

（4）循环执行以下操作：a.从就绪队列中取出优先级最高的进程，执行该进程。

b.如果有更高优先级的进程到来，则将当前进程放回就绪队列中，将新到来的进程放入就绪队列中。

c.如果当前进程执行完毕，则将其从就绪队列中移除。

d.如果当前进程被阻塞，则将其从就绪队列中移除，放入阻塞队列中。

e.如果阻塞队列中有进程被唤醒，则将其放回就绪队列中。

3.观察和分析该算法的优缺点。

优点：（1）能够充分利用CPU资源，提高系统的响应速度。

（2）能够保证高优先级进程的及时响应，提高系统的实时性。

缺点：（1）可能会出现“饥饿”现象，即低优先级进程无法得到执行。

（2）可能会出现“优先级反转”现象，即低优先级进程占用了高优先级进程所需的资源，导致高优先级进程无法得到及时响应。

五、实验结果经过实验，我们发现抢占式优先级调度算法能够有效地提高系统的响应速度和实时性，但也存在一些缺点，需要根据具体情况进行优化。