使用动态优先权的进程调度算法的模拟实验
进程管理实验报告
实验名称: 进程管理实验要求:阅读后面的C语言实例，修改程序，使其优先数在运行期间可以变化(动态优先数)。
例如，当某进程被时间片中断次数增加到一定数目时，提高其优先权。
关键问题:读懂源程序代码，了解进程管理的方式，并设计一个算法使程序能在运行过程中修改进程优先级。
设计思路:在进程控制块中定义一个记录进程中断次数的变量，在block函数中设置跟踪并记录进程中断次数，在调度函数schedule中设置算法，在进程中断3次后将该进程的优先级提升至最高。
改动后的代码:#include <stdio.h>#define TRUE 1#define FALSE 0#define MAXPRI 100#define NIL -1//进程控制块struct {int id; //进程号char status; //进程状态，'e'-执行态'r'-高就绪态't'-低就绪态'w'-等待态'c'-完成态int nextwr; //等待链指针，指示在同一信号量上等待的下一个等待进程的进程号。
int priority; //进程优先数，值越小，优先级越高。
int c;//进程中断次数}pcb[3];//共3个进程//s1、s2为三个进程共享的变量；seed为随机值；registeri模拟寄存器值,存放计算的重复次数。
int registeri,s1,s2,seed,exe=NIL;//exe为当前运行（占有cpu）的进程号//2个信号量sem[0]、sem[1],分别与共享变量s1、s2相联系。
//对应信号量sem[0]、sem[1]分别有两个阻塞队列，队列首由sem[].firstwr指定，队列链指针是pcb[].nextwrstruct{int value;//信号量值int firstwr;//等待该信号量的阻塞队列的首个进程号}sem[2];//三个进程的现场保留区，其中savearea[][0]为寄存器内容，savearea[][1]为下一条指令地址。
操作系统 实验 进程调度 银行家算法 多线程编程 存储管理 磁盘调度
实验一进程调度实验学时：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个进程--------------请输入进程数:实验二银行家算法一、实验目的死锁会引起计算机工作僵死，因此操作系统中必须防止。
操作系统课程设计报告-进程调度算法模拟
1．课程设计的目的《操作系统原理》课程设计我们专业实践性环节之一，是学习完《操作系统原理》课程后进行的一次较全面的综合练习。
其目的在于加深对操作系统的理论、方法和基础知识的理解，掌握操作系统结构、实现机理和各种典型算法，系统地了解操作系统的设计和实现思路，培养学生的系统设计能力，并了解操作系统的发展动向和趋势。
2．课程设计的内容及要求先来先服务、短作业优先、时间片轮转、基于静态优先级的调度，基于高响应比优先的动态优先级调度算法实现，能够输出调度情况，并计算周转时间和平均周转时间。
要求使用链表，进程个数由用户提供，按照进程的实际个数生成PCB，程序能够让用户选择使用哪种调度算法，能够在Linux环境运行并验证结果。
程序要考虑用户界面的友好性和使用方便性。
进程基本信息可从文件读入，也可手动输入。
3、设计原理3.1先来先服务调度算法每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源创建进程，然后放入就绪队列3.2短作业优先调度算法短作业优先调度算法是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
3.3时间片轮转调度算法系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU分配给队首进程，并令其执行一个时间片。
时间片的大小从几ms到几百ms。
当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。
3.4静态优先级调度算法把处理机分配给优先级最高的进程，使之执行。
但在其执行期间，只要出现了另一个比其优先级更高的进程，调度程序就将处理机分配给新到的优先级最高的进程。
这样就可以保证紧迫性作业优先运行。
3.5最高响应比优先的动态优先级调度算法优先权调度算法是为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入最高优先权优先调度算法。
操作系统实验报告
pf2 = 0；
void IntDelete ( )
{
kill(pidl，16);
kill(pid2，17);
EndFlag = 1;
}
void Intl ( )
{
printf (“ child process l is killed! by parent \n”);
exit (0)；
if (pid＝0)
{
signal ( SIGUSRl，Intl )；
signal (SIGINT，SIG_IGN);
pause( )；
exit(0)；
}
else
{
while ((pid = fork ( )) = -1);
if(pid2 = 0 )
{
signal(SIGUSRl，Intl)；
signal(SIGINT，SIG_IGN);
write (fd[1]，OutPipe，50)；
sleep (5)；
lockf (fd[l]，0，0)；
exit(0)；
}
else
{
wait (0);
read (fd[0 ]，InPipe，50);
printf(“％s\n”，InPipe)；
wait(0)；
read(fd[0]，InPipe，50)；
signal (16，stop);
printf(%d”,SIG_DEL);
waiting ( )；
lockf (stdout，1，0);
printf ("child process 1 is killed by parent!\n”);
1ockf ( stdout，0，0);
使用动态优先权的进程调度算法的模拟
使用动态优先权的进程调度算法的模拟动态优先权（Dynamic Priority）调度算法是一种根据进程的行为动态调整其优先级的调度算法。
它是对静态优先权调度算法的一种改进，能够更加灵活和有效地调度进程。
下面我将通过模拟的方式详细介绍动态优先权调度算法。
在动态优先权调度算法中，每个进程都有一个初始优先级，等待时间越长，优先级越高。
当进程开始执行时，系统根据其行为调整它的优先级。
假设有五个进程ReadyQueue={P1, P2, P3, P4, P5}，它们的初始优先级分别为{10, 20, 30, 40, 50}。
每个进程的服务时间分别为{6, 7, 8, 9, 10}。
1.初始化阶段：-进程P1开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-正在运行的时间是指进程执行过程中已经消耗的时间。
2.执行阶段：-进程P1运行6个时间单位后，它已经完成了自己的服务时间。
这时，系统将调度下一个优先级最高的进程P5运行。
-进程P5开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
因为P5执行是第一次运行，所以其正在运行的时间为0。
-进程P5运行10个时间单位后，它也完成了自己的服务时间。
3.更新优先级阶段：-进程P5完成后，进程P2开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P2运行7个时间单位后，它完成了自己的服务时间。
4.重新排序阶段：-进程P3开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P3运行8个时间单位后，它也完成了自己的服务时间。
5.最后的执行阶段：-进程P4开始执行，系统将其优先级设置为初始优先级减去正在运行的时间。
-进程P4运行9个时间单位后，完成了自己的服务时间。
至此，所有的进程都已经完成了它们的服务时间。
动态优先权调度算法的核心思想是，等待时间越长，优先级越高。
这样做的原因是为了避免饥饿的产生，即一些低优先级的进程因为等待时间太长而无法得到运行。
进程调度模拟设计——时间片轮转、优先级法
学号：课程设计课程名字系统软件开发实训A题目进程调度模拟设计——时间片轮转、优先级法学院专业班级姓名指导教师2014 年01 月17 日课程设计任务书学生姓名：专业班级：指导教师：工作单位：题目: 进程调度模拟设计——时间片轮转、优先级法初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：⑴课程设计目的与功能；⑵需求分析，数据结构或模块说明(功能与框图)；⑶源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结。
时间安排：设计安排3周：查阅、分析资料 1天系统软件的分析与建模 4天系统软件的设计 5天系统软件的实现 3天撰写文档 1天课程设计验收答辩 1天设计验收安排：设计周的第三周的指定时间到实验室进行上机验收。
设计报告书收取时间：课程设计验收答辩完结时。
（注意事项：严禁抄袭，一旦发现，抄与被抄的一律按0分记）指导教师签名： 2013 年 12 月 10日系主任（或责任教师）签名： 2013 年 12 月 10日进程调度模拟设计——时间片轮转、优先级法1设计目的1.1 阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解，能够使用其中的方法来进行进程调度模拟设计。
1.2 练掌握并运用时间片轮转和优先级法，掌握一种计算机高级语言的使用。
2 设计要求2.1 能够选择不同的调度算法（要求中给出的调度算法）；2.2 能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；2.3 根据选择的调度算法显示进程调度队列；2.4 根据选择的调度算法计算平均周转时间和平均带权周转时间。
使用动态优先权的进程调度算法的模拟实验
使用动态优先权的进程调度算法的模拟实验进程调度算法是操作系统中对进程进行调度的一种策略，动态优先权调度算法是其中一种常用的调度算法。
下面将对动态优先权调度算法进行模拟实验，并对实验结果进行分析。
首先，我们定义进程的属性包括进程编号、到达时间、服务时间、优先权和完成时间等。
动态优先权调度算法的基本思想是根据进程的优先权决定下一个被调度的进程，优先权越高，被调度的机会越大。
实验过程如下：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号进程成为当前进程，开始执行。
进程调度模拟设计——优先级法、最高响应比优先调度算法
附件1：课程设计进程调度模拟设计——优先级题目法、最高响应比优先调度算法学院计算机科学与技术专业计算机科学与技术班级计算机科学与技术姓名指导教师2011 年01 月18 日课程设计任务书学生姓名：专业班级：计算机科学与技术指导教师：工作单位：计算机科学与技术学院题目: 进程调度模拟设计——优先级法、最高响应比优先调度算法初始条件：1．预备内容：阅读操作系统的处理机管理章节内容，对进程调度的功能以及进程调度算法有深入的理解。
2．实践准备：掌握一种计算机高级语言的使用。
要求完成的主要任务:（包括课程设计工作量及其技术要求，以及说明书撰写等具体要求）1．模拟进程调度，能够处理以下的情形：⑴能够选择不同的调度算法（要求中给出的调度算法）；⑵能够输入进程的基本信息，如进程名、优先级、到达时间和运行时间等；⑶根据选择的调度算法显示进程调度队列；⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2．设计报告内容应说明：⑴课程设计目的与功能；⑵需求分析，数据结构或模块说明(功能与框图)；⑶源程序的主要部分；⑷测试用例，运行结果与运行情况分析；⑸自我评价与总结：i）你认为你完成的设计哪些地方做得比较好或比较出色；ii）什么地方做得不太好，以后如何改正；iii）从本设计得到的收获（在编写，调试，执行过程中的经验和教训）；iv）完成本题是否有其他方法（如果有，简要说明该方法）；v）对实验题的评价和改进意见，请你推荐设计题目。
时间安排：设计安排一周：周1、周2：完成程序分析及设计。
周2、周3：完成程序调试及测试。
周4、周5：验收、撰写课程设计报告。
（注意事项：严禁抄袭，一旦发现，抄与被抄的一律按0分记）指导教师签名：年月日系主任（或责任教师）签名：年月日进程调度模拟设计（优先级法、最高响应比优先调度算法）1设计目的与实现功能模拟进程调度，使程序能够完成：选择不同的调度算法（优先级法或者最高响应比法），选毕算法，能够输入若干进程，包括进程的一些基本信息，如进程名、优先级、到达时间和运行时间等；根据选择的调度算法显示进程调度队列；根据选择的调度算法计算平均周转时间和平均带权周转时间。
动态优先权进程调度算法模拟实验报告
华北电力大学实验报告实验名称动态优先权进程调度算法模拟课程名称计算机操作系统专业班级：学生姓名：学号：成绩：指导教师：实验日期：一﹑实验目的：通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
二﹑实验内容：（1）用C语言（或其它语言，如Java）实现对N个进程采用某种进程调度算法（如动态优先权调度）的调度。
（2）每个用来标识进程的进程控制块PCB可用结构来描述，包括以下字段：✧进程标识数ID。
✧进程优先数PRIORITY，并规定优先数越大的进程，其优先权越高。
✧进程已占用CPU时间CPUTIME。
✧进程还需占用的CPU时间ALLTIME。
当进程运行完毕时，ALLTIME变为0。
✧进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，进程将进入阻塞状态。
✧进程被阻塞的时间BLOCKTIME，表示已阻塞的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
✧进程状态STATE。
✧队列指针NEXT，用来将PCB排成队列。
（3）优先数改变的原则：✧进程在就绪队列中呆一个时间片，优先数增加1。
✧进程每运行一个时间片，优先数减3。
（4）为了清楚地观察每个进程的调度过程，程序应将每个时间片内的进程的情况显示出来，包括正在运行的进程，处于就绪队列中的进程和处于阻塞队列中的进程。
（5）分析程序运行的结果，谈一下自己的认识。
三、设计思路和方法通过VC++程序模拟动态优先权程序调度算法，主要思路和方法就是，通过结构体模拟计算机的控制模组，构造一个PCB结构体即进程控制块结构体，用来记录当前进程的的相关状态信息，包括进程标识符、处理机状态、进程调度信息、进程控制信息。
并通过C++语言模拟计算机的相关调度算法，对构建的PCB进程进行模拟调度和运行，从而实现用计算机对进程的调度过程进行过程仿真。
四、数据结构和算法数据结构：1.包含PCB信息的结构体2.包含进程信息的顺序表结构算法：优先权=(等待时间+要求服务时间)/要求服务时间R p=(等待时间+要求服务时间)/要求服务时间=相应时间/要求服务时间系统将所有就绪队列按优先级高低排成一个队列，每次调度时，将CPU分配给优先级最高的进程，并令其执行一个时间片，而后中断，寻找并运行下一个优先级最高的进程。
操作系统综合性实验报告-进程调度(含代码)
int count;
// 记录进程执行的次数
struct node *next;
// 队列指针
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; // 和完成队列
定义三个队列， 就绪队列， 执 行队列
int num; void GetFirst(); void Output(); void InsertTime(PCB *in); void InsertFinish(PCB *in); TimeCreate(); void RoundRun(); void main() {
三、实验内容
1. 用 C 语言（或其它语言，如 Java ）编程实现对 N 个进程采用某种进程调度算
法（如动态优先权调度算法、先来先服务算法、短进程优先算法、时间片轮转调度
算法）调度执行的模拟。
2. 每个用来标识进程的进程控制块 typedef struct node {
PCB 可用结构来描述，包括以下字段：
一个时间片，当执行完时，有一个计时器发出时钟中断请求，该进程停止，并被送
到就绪队列的末尾，然后再把处理机分配就绪队列的队列进程，同时也让它执行一
个时间片。 （ 3 ）、通过亲手实验， 对上述写的时间片的工作流程和原理有了更贴切的认识。
另外本次实验遇到了很大的麻烦，其实大部分代码是借鉴网上的，但自己通过修改， 来获取自己想要的，在自己的努力和同学的帮助下终于调试正确，很是高兴。
void InsertTime(PCB *in)
// 将进程插入到就绪队列尾部
{ PCB *fst; fst = ready;
if(ready == NULL) {
in->next = ready; ready = in; } else { while(fst->next != NULL) {
实验二FPF和RR调度算法
1. 设计进程控制块(PCB)的数据结构 – 应包含实验必须的数据项，如进程 ID、需要的服务时 间、进入系统时间、完成时间、周转时间、优先权、 进程状态（R-运行，W-等待），以及实验者认为有必 要的其他数据项。 2. 实现排序算法（将就绪队列中的进程排序） – RR：只需在开始时排序，按 FCFS 策略将进程依次插 入就绪队列。开始运行后不再需要排序，按 RR 策略将 每一个刚刚运行完一个时间片的进程插入到队尾。 – FPF：每次调度前排序，按计算所得的动态优先权排成 有序队列，最高优先权排进程在队首，优先权相同的 进程按 FCFS 策略排队。 3. 实现 RR 调度过程模拟
if (ap == NULL) {
pt = psorted->next; psorted = pt; } else
ap->next = pt->next; } ap = pt; pt = pt->next; } if (psorted->next == NULL) break; getchar(); } } struct PCB* SortList(PCB* HL) { struct PCB* SL; SL = (struct PCB*)malloc(sizeof(struct PCB)); SL = NULL;
按回车键进入演示程序
printf(" 法。");
1.演示最高优先数优先算
printf(" 按 1 继续:"); char ch = getchar(); return ch; system("cls"); } void HighPriority() { struct PCB *processes, *pt; //pt 作为临时节点来创建链表，使用 for 语句，限制进程数为 5个
黄天实验三进程调度实验报告
操作系统实验实验三进程调度学号 1415251011 姓名黄天班级 14集成1班华侨大学电子工程系实验目的1、理解有关进程控制块、进程队列的概念。
2、掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。
实验内容与基本要求1、设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。
2、建立进程就绪队列。
3、编制两种进程调度算法：优先权调度算法和时间片轮转调度算法。
实验报告内容1、优先权调度算法和时间片轮转调度算法原理。
优先权调度算法原理：（此处为静态优先权）当该算法用于作业调度时，系统从后备作业队列中选择若干个优先级最高的，且系统能满足资源要求的作业装入内存运行。
当该算法用于进程调度时，将把处理机分配给就绪进程队列中优先级最高的进程。
在这种调度方式下，系统一旦把处理机分配给就绪队列中优先级最高的进程后，该进程就能一直执行下去，直至完成；或因等待某事件的发生使该进程不得不放弃处理机时，系统才能将处理机分配给另一个优先级高的就绪进程。
时间片轮转调度算法原理：在早期的时间片轮转法中,系统将所有的就绪进程按先来先服务的原则,排成一个队列,每次调度时,把CPU分配给队首进程,并令其执行一个时间片.时间片的大小从几ms到几百ms.当执行的时间片用完时,由一个计时器发出时钟中断请求,调度程序便据此信号来停止该进程的执行,并将它送往就绪队列的末尾;然后,再把处理机分配给就绪队列中新的队首进程,同时也让它执行一个时间片.这样就可以保证就绪队列中的所有进程,在一给定的时间内,均能获得一时间片的处理机执行时间.4、运行结果以及结论。
1.优先权调度算法：这里采取的是短时间优先算法运行结果结果表明，占用时间最少得程序，最先运行，依次进行。
结论:程序很好的完成了实验要求所要达到的目标，进行短时间优先运行。
2.时间片轮转算法：每个时间片大小为1.每个程序轮转一次程序运行结果结论：程序运行结果表明，所有程序按照时间片来轮转，每个程序运行一个时间片后轮到下一个程序，直到所有程序运行完。
os指导书3
操作系统教学大纲【课程编码】JSZB0020【适用专业】计算机科学与技术【课时】理论课时：72，实验课时：20【学分】 4【课程性质、目标和要求】操作系统是计算机科学与技术专业的专业课。
操作系统是计算机系统配置的基本系统软件之一，在计算机系统软件中占有极其重要的地位。
本课程在介绍操作系统一般原理的基础上，详细介绍了UNIX操作系统的实现。
通过理论联系实际的教学，使学生能较系统地了解计算机操作系统的基本概念、工作原理、设计目标和主要的算法和技术，培养学生分析和设计操作系统的初步能力，为今后进一步从事计算机操作系统和系统软件的分析、研制和开发打下良好的基础。
课程基本要求1.掌握操作系统的基本概念和原理，并对计算机操作系统有整体的概念；2.了解组成计算机操作系统各模块的工作过程及有关的算法；3.熟悉UNIX操作系统的系统结构、各主要模块以及模块之间的关系；4.了解计算机操作系统最新的技术发展。
【教学时间安排】本课程计 4 学分，理论课时72+实验课时20, 学时分配如下：【教学内容要点】第一章操作系统引论一、学习目的要求掌握操作系统基本概念。
二、主要教学内容1、操作系统的目标和作用2、操作系统的发展过程3、操作系统的基本特征和功能4、操作系统的结构设计第二章进程管理一、学习目的要求本章主要讲述进程和线程的基本概念，要求掌握进程的基本概念、进程控制、进程同步、进程间通信和线程等概念。
二、主要教学内容1、进程的基本概念2、进程控制3、进程同步4、经典进程的同步问题5、管程机制6、进程通信7、线程第三章处理机调度与死锁一、学习目的要求本章主要讲述OS中的调度以及死锁的概念，要求掌握处理机调度的概念、进程调度算法、实时调度、多处理机调度以及死锁的概念和处理方法。
二、主要教学内容1、处理机调度的基本概念2、调度算法3、实时调度4、多处理机系统中的调度5、死锁的基本概念6、处理死锁的基本方法第四章存储器管理一、学习目的要求本章主要讲述内存的各种管理方式，要求掌握分区式、页式、段式、段页式存储管理方式，以及虚拟存储器的基本概念和请求调页、请求调段存储管理方式。
进程调度算法实验报告
实验报告实验一：进程调度算法一、实验目的1．利用高级语言实现三种不同及进程调度算法：短作业优先算法、时间片轮转调度算法和优先级调度算法。
2．通过实验理解有关进程控制块，进程队列等的概念。
二、实验原理各调度算法思想：1.先来先服务算法(FCFS)：按照进程进入就绪队列的先后次序来分配CPU，一旦一个进程占有CPU，就一直运行下去，知道该进程完成工作，才释放CPU。
2.时间片轮转算法:系统将所有就绪进程按到达时间的先后次序排成一个队列，进程调度程序总是选择队列中的第一个进程执行，且仅能执行一个时间片，在使用完一个时间片后，即使进程并未完成其运行，也必须将CPU交给下一个进程；如果一个时间片未使用完就完成了该进程，则剩下的时间分配给下一个进程。
3.优先权调度算法；在创建进程时就确定优先权，确定之后在整个程序运行期间不再改变，根据优先级排列，系统会把CPU分配给优先权最高的进程。
三、实验步骤、数据记录及处理1、算法流程抽象数据类型的定义：PCB块结构体类型struct PCB{int name;int arrivetime; //到达时间int servicetime; //服务时间//int starttime[max]; //开始时间int finishtime; //完成/结束时间int turntime; //周转时间int average_turntime; //带权周转时间int sign; //标志进程是否完成int remain_time; //剩余时间int priority; //优先级}pcb[max];主程序的流程以及各程序模块之间的层次(调用)关系：主程序中从键盘得到进程的数量，创建PCB，调用layout（）函数显示选择界面。
Layout（）函数中选择相应的算法并调用相关函数如：FCFS()、time_segment();、Priority()，这三个函数分别实现先来先服务算法，时间片轮转算法和优先级算法，最后分别打印。
进程调度 实验报告
一、实验目的 多道程序设计中，经常是若干个进程同时处于就绪状态，必须依照某种策略来决定那
个进程优先占有处理机。因而引起进程调度。本实验模拟在单处理机情况下的处理机调度 问题，加深对进程调度的理解。 二、实验内容 1．优先权法、轮转法
简化假设 1）进程为计算型的（无 I/O） 2）进程状态：ready、running、finish 3）进程需要的 CPU 时间以时间片为单位确定 2．算法描述 1） 优先权法——动态优先权
/*******************优先权调度算法所需函数 *****************************************************/ struct process1*creatlist1(int n) {
srand((int)time(0)); struct process1 *first =new process1; first ->next=NULL; for (int i=0;i<n;i++) {
struct process1 *s; s =new process1; s->pcb =i; s-> privilege=random(20)+5; s->cpu=random(20)+1; insert1(first,s ); } return first; } void insert1(struct process1 *first,struct process1 *s) //插入节点 { struct process1 *p=search(first,s); s->next=p->next; p->next=s; //return; }
基于动态优先权的进程调度算法的模拟实现
在多道程序环境下, 进程的数目往往多于处理机数 目。这就要求 系统能按照某种算法, 动态的把处理机分配给就绪队列中 的进程, 使 之执行。因此, 处理机调度是操作系统设计的中心问题之一。进程调度 问 题 的 核 心 就 是采 用 什 么 样 的 算 法 把 处 理 机 分 配 给 进 程 。进 程 调 度 算 法 也 是 在 任 何 操作 系 统 中 必 须 配 置 的 一 级 调 度 。好 的 进 程 调 度 算 法 将 有效的提高系统中 各种资源利用 率, 减少处理机 的空闲时间, 避 免部 分 作 业 长 期 得不 到 处 理 机 响 应 等 情 况 的 发 生 。
1 . 动 态 优 先 权 调度 算 法 介 绍 动态优先权调度算法, 以就绪队列中各个进程的优 先权作为进程 调度的依据。各个进程的优先权在创建进程时所赋予, 随着进程的推 进 或 其 等 待 时间 的 增 加 而 改 变 。进 程 的 优 先 权 利 用 某 一 范 围 内 的 整 数 来表示。有的系统数值越小优先权越高, 如 Uni x 系统, 有的系统则反 之。采用该算法时, 每次总是在就绪队列中选择一个优 先权最高的进 程进行调度, 并将处理机分配给该进程。动态优先权调 度算法又分为 抢占式和非抢占式两种。本文采用 C 语言对非抢占式动态优先权调度 算 法 进 行 了 设 计和 实 现 。 2 . 算 法 的 设 计 思路 (1 ) 在算法的设计中各项原则。 首 先 规 定优 先 数 改 变 的 原 则 : ● 进程在就绪队列中呆一个时间片, 优先数增加 1 。 ● 进程每运行一个时间片, 优先数减 3。 其次, 算法的数据结构及操作采 用数组方式, 将输入的 N个 进程 的 PCB 信息保存到一个数组中。用 PCB 数组的插入和 删除动态地模 拟 进 程 调 度 过程 。 (2 ) 系统初始条件。 系统中设有 5 个进程, 每个进程产生时间, 优先级各不相同。利用 进程控制块 PCB 来 描述各个进程。进程控制块 PCB 包括以下字段: ● 进程标识数 ID; ● 进程优先数 PRIORITY, 并规定优先数越大的进程, 其优先权越 高; ● 进程已占用的 CPU 时间 CPUTIME; ● 进 程还 需占 用的 CPU 时间 ALLTIME。 当进 程 运行 完毕 时 , ALLTIME 变为 0 ; ● 进 程 的 阻 塞 时 间 STARTBLOCK, 表 示 当 进 程 再 运 行 STARTBLOCK 个时间片后, 进程将进入阻塞状态; ● 进程 被阻塞 的时间 BLOCKTIME, 表示已 阻塞 的进程 再等 待 BLOCKTIME 个时间片后, 进程将转换成就绪状态; ● 进程状态 STATE, 包括三种状态, 就绪态、阻塞态、完成态; CPU 处理进 程是从就绪队 列中选择当前各 进程中优先权最 大的 进程开始的。由于采用的是非抢占式调度算法, 则当前 进程执行完一 个 时 间 片 之 后有 以 下 几 种 情 况 : ① 当前进程结束则退出系统, 否则排到就绪队列尾 或根据阻塞时
高优先权优先的进程调度算法模拟
高优先权优先的进程调度算法模拟进程调度算法是操作系统中的一个重要组成部分，其中高（动态）优先权优先调度算法是一种常用的调度算法。
本文将通过模拟该算法的工作原理、实现过程和应用场景等方面，详细介绍高（动态）优先权优先进程调度算法。
一、高（动态）优先权优先进程调度算法的原理及特点：1.原理：高（动态）优先权优先进程调度算法根据进程的优先权值来确定进程执行的顺序，优先权值高的进程先执行。
在这种算法中，每个进程都有一个优先权值，优先权值越大，进程执行的优先级也越高。
2.特点：（1）动态性：高（动态）优先权优先进程调度算法中，进程的优先权值可以根据进程的状态和需求进行动态调整。
例如，用户交互进程或实时进程的优先权值可以较高，而后台进程的优先权值可以较低。
（2）公平性：高（动态）优先权优先进程调度算法能够保证每个进程都有执行的机会，不会出现饥饿现象。
（3）无法避免的问题：由于优先权值的动态调整，高（动态）优先权优先进程调度算法可能导致一些进程饥饿或低优先级进程无法得到执行的情况。
二、高（动态）优先权优先进程调度算法的实现过程：1.初始化：设定每个进程的优先权值，创建就绪队列和堆栈等数据结构，初始化进程的状态和资源。
2. 进程调度：根据进程的优先权值，从就绪队列中选择优先权值最高的进程进行执行。
如果存在多个优先权值相同的进程，可以使用先到先服务（FIFO）或轮转（Round-robin）等调度策略来决定执行顺序。
3.执行进程：将选中的进程从就绪队列中移除，并切换到该进程的上下文，开始执行进程的指令。
4.中断处理或进程阻塞：在进程执行过程中，如果发生中断事件（如I/O请求、信号响应等），则暂停当前进程的执行，并将其状态置为阻塞态，将进程放入阻塞队列中等待事件完成或唤醒信号。
5.进程唤醒或时间片过期：当进程阻塞的事件完成或等待一段时间后，重新将该进程放入就绪队列中，更新其优先权值。
6.进程终止或等待：当进程执行完所有指令或主动请求等待时，将进程从系统中移除，并释放其占用的资源。
操作系统进程调度实验报告
实验报告课程名称计算机操作系统实验名称进程及其管理班级学号姓名成绩指导教师赵安科实验日期2015年5月21日一．实验题目：进程及其管理二．实验内容：设计一个简单的进程调度算法，模拟OS 中的进程调度过程 三．实验要求：① 进程数不少于5个；② 进程调度算法任选；最好选用动态优先数法，每运行一个时间片优先数减3 ③ 用C++（或C ）语言编程； ④ 程序运行时显示进程调度过程。
四．实验步骤：① 设计PCB 及其数据结构： 进程标识数：ID进程优先数：PRIORITY （优先数越大，优先级越高） 进程已占用时间片：CPUTIME进程尚需时间片：ALLTIME （一旦运行完毕，ALLTIME 为0） 进程队列指针：NEXT ，用来将PCB 排成队列 进程状态：STATE （一般为就绪，不用） ② 设计进程就绪队列及数据结构；③ 设计进程调度算法，并画出程序流程图； ④ 设计输入数据和输出格式； 结构格式：当前正运行的进程：0 当前就绪队列：2，1，3，4 ⑤ 编程上机，验证结果。
五．实验说明：假设调度前，系统中有5个进程，其初始状态如下： ID 0 1 2 3 4 可否考虑用二维数组去实现PRIORITY 9 38 30 29 0 CPUTIME 0 0 0 0 0 ALLTIME 3 3 6 3 4 STATE readyreadyreadyreadyready① 以时间片为单位调度运行；② 每次总是从ALLTIME 中不为0，且PRIORITY 最大的进程调度运行一个时间片；③上述进程运行后其优先数减3，再修改其CPUTIME和ALLTIME，重复②，③④直到所有进程的ALLTIME均变为0。
六．程序中所用数据结构及说明：程序中定义了一个二维数组pc用于存储5个进程对应的属性，在程序动态执行的过程中随时修改各个进程对应的属性，直到所有进程消耗完时间片为止，同时为了更方便的了解进程执行的过程，添加了一个priority函数，用于动态的显示就绪队列进程的优先数（由大到小排列），以及对应的进程ID号，这样在程序执行的过程中，能清楚下一步该运行的就绪队列中的进程，更方便检查程序执行的过程中进程的调度是否有错误。
进程调度实验报告
操作系统实验 报告实验项目： 进程调度学 院： 计算机学院专 业：班 级：学 号：姓 名：1. 实验目的在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。
当就绪进程个数大于处理机数时，就必须依照某种策略来决定哪些进程优先占用处理机。
本实验模拟在单处理机情况下的进程调度，加深了解进程调度的工作。
2. 实验内容设计一个按时间片轮转法实现进程调度的程序。
(1)假定系统有五个进程，每一个进程用一个进程控制块PCB 来代表，进程控制块的格式为：其中，进程名——作为进程的标识，假设五个进程的进程名分别为Q 1，Q 2，Q 3，Q 4，Q 5。
指针——进程按顺序排成循环队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程的指针指出第一个进程的进程控制块首地址。
要求运行时间——假设进程需要运行的单位时间数。
已运行时间——假设进程已经运行的单位时间数，初始值为“0”。
状态——有两种状态，“就绪”和“结束”，初始状态都为“就绪”，用“R ”表示。
当一个进程运行结束后，它的状态为“结束”，用“E ”表示。
(2)每次运行所设计的进程调度程序前，为每个进程任意确定它的“要求运行时间”。
(3)把五个进程按顺序排成循环队列，用指针指出队列连接情况。
另用一标志单元记录轮到运行的进程。
例如，当前轮到Q 2执行，则有：进程名 指针 要求运行时间 已运行时间 状态标志单元(4)进程调度总是选择标志单元指示的进程运行。
由于本实验是模拟进程调度的功能，所以对被选中的进程并不实际的启动运行，而是执行“已运行时间+1”来模拟进程的一次运行，表示进程已经运行过一个单位的时间。
请注意：在实际的系统中，当一个进程被选中运行时，必须置上该进程可以运行的时间片值，以及恢复进程的现场，让它占有处理机运行，直到出现等待事件或运行满一个时间片。
在这时省去了这些工作，仅用“已运行时间+1”来表示进程已经运行满一个时间片。
(5)进程运行一次后，应把该进程的进程控制块中的指针值送到标志单元，以指示下一个轮到运行的进程。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
ｉnt i;//i为循环计数器
ＰCB *heaｄ,*temｐ1,＊temp2, *teｍp3；/／heａｄ为就绪队列的头指针，tｅｍp1为创建进程结点的指针,temp2、teｍp３分别为比较结点的前驱结点和比较结点
ｆor(i＝0;i<nuｍ；i++)//根据进程的个数创建结点并按从大到小的顺序进行排序
使用动态优先权的进程调度算法的模拟实验
———————————————————————————————— 作者：
———————————————————————————————— 日期:
ﻩ
使用动态优先权的进程调度算法的模拟实验
1.实验目的
通过动态优先权算法的模拟加深对进程概念和进程调度过程的理解。
2.实验内容
3.过程（流程图）
4.代码
#inｃｌｕde <stｄiｏ.ｈ>
#iｎclude＜stｄｌib.ｈ>
#incｌude <sｔrｉng.h>
typedef struｃｔnoｄe
{
iｎt iｄ;//进程标识数
ﻩiｎtｐrioｒiｔy;/／进程优先数，优先数越大优先级越高
int cputime;//进程已占用的CPU时间
ﻩtｅmp2=ｔeｍp１-＞nｅxt;
}
temp1－＞ｎexｔ=rｕn；
SＴATEﻩＲEＡDYREADＹﻩREAＤYＲEADYREAＤＹ
(5）为了清楚地观察诸进程的调度过程，程序应将每个时间片内的进程的情况显示出来,参照的具体格式如下：
RＵNＮINＧPROＧ:i
READY_ＱＵＥUE：-＞iｄ1->iｄ２
BLOＣK_QUEUE：->id3->id4
＝===＝====＝====＝==＝＝====＝===＝==＝====＝===＝===＝====＝=＝===＝====＝＝====＝＝==＝
ﻩiｎt alltime;//进程还需占用的ＣPＵ时间
ﻩｉnｔsｔａrtbｌｏck；//进程的阻塞时间
ﻩintｂｌocktime；//进程被阻塞的时间
charｓtａｔe[１０]；//进程状态
struct noｄe＊ｎeｘt;//队列指针
}PCB；
PCB *CreaｔQueue(ｉntｎum)/／创建一个就绪队列
｛
ﻩﻩﻩteｍp2=temp３;
ﻩﻩﻩｔemp３=ｔｅｍp2->nexｔ;
｝
ﻩﻩtｅｍp2->nｅxt=ｔemp1；
temｐ１->ｎeｘt=tｅmp3；
ﻩ}
ﻩｒetuｒn hｅad;
}
PCB *IｎsertＱuｅue(PCＢ＊ｈead,PＣB *ｒun）//在就绪队列中插入一个结点
{
PＣB *ｔemp1,*tｅmp2;／／temp1和tｅmp２分别为比较结点的前驱和比较结点
进程的阻塞时间ｓtartbloｃk，表示当进程再运行sｔartblock个时间片后,进程将进入阻塞状态；
进程被阻塞的时间bｌiｃktime，表示已阻塞的进程再等待blocｋtｉme个时间片后,将转换为就绪态；
进程状态sｔatｅ;
队列指针nexｔ,用来将PCB排成队列。
（3)优先数改变的原则：
进程在就绪队列中呆一个时间片，优先数增加１.
进程每运行一个时间片,优先数减３。
（４)假设在调度前,系统中有5个进程，它们得初始状态如下：
ID ﻩ01ﻩﻩ２3ﻩﻩ4
PRＩORＩＴY93８3０ﻩﻩ2９ﻩ0
CPUTＩME０0ﻩﻩ０ﻩﻩ00
ALLTIＭE33ﻩ6ﻩ3ﻩﻩ4
STARＴBＬＯCK2－1ﻩﻩ-1-1ﻩﻩ－1
BLOCＫTIME30ﻩ0ﻩ0ﻩ0
ﻩ{
ﻩﻩtｅｍp1=（PCB *)malｌｏｃ(sizｅoｆ（PCB）);
ﻩprinｔf(＂输入第％d个进程的(iｄ…sｔate)＼n＂,i);
ﻩｓcanｆ("%d%d%ｄ%d％ｄ%d%s"，＆teｍｐ1->id,&temp1->prioritｙ,&teｍp1-＞cputime,&temp1->ａlｌtimｅ,&temp1-＞stａｒtblocｋ,&temｐ1->bloｃktime,temp1->statｅ)；
}
ﻩelｓe
ﻩ{
temp1=hｅad；／/ｔｅmｐ1为比较结点的直接前驱结点
ﻩ temｐ2＝teｍp1－>neｘt;//tｅｍp２为比较的结点
ﻩ while(ｔemｐ2!=NＵLL && temｐ２－＞ｐrioｒｉｔy>=ｒｕn-＞priｏrity)／/实现查找的功能
ﻩ{
ﻩﻩtemｐ1=ｔemｐ2;
IDﻩ0ﻩﻩ12ﻩﻩ３ﻩ4
PRIORＩTＹﻩ ﻩP0 P１P2P3P4
CPUTＩMEC０ﻩﻩC1ﻩC3ﻩﻩC4ﻩﻩC5
AＬＬTIＭＥﻩA0ﻩA1ﻩA２ﻩﻩA３ﻩﻩA4
SＴARTBLOCKT0ﻩＴ1ﻩＴ2ﻩT3ﻩT4
BLOＣＫTＩMEﻩB0ﻩﻩＢ1ﻩB2Ｂ3ﻩB4
STATEＳ0S1ﻩﻩS2ﻩＳ3ﻩS4
ﻩiｆ（hｅad==ＮUＬL）//如果就绪队列为空
ﻩ{
ﻩheaｄ＝run;
ｈｅad->nｅxｔ＝ＮULL;
｝
ｅlsｅiｆ(heaｄ->priｏrｉｔｙ< run-＞pｒioriｔy)//如果插入结点中所保存的数比头结点所保存的数要大，则直接把该结点插入到头结点之前
{
ﻩrｕｎ－>ｎeｘt=head;
ﻩｈead＝rｕｎ;
ﻩhead＝tｅmp1;
continue;
ﻩﻩ}
ﻩtemｐ2=head；／／tｅmp2为比较结点的直接前驱结点
ﻩtｅmp３＝tｅmｐ２->ｎｅxt;//temp3为比较的结点
ﻩﻩｗhｉｌe(ｔemp3!=ＮULL＆& teｍｐ3->priority＞=tｅmp1->ｐriｏriｔy) //实现查找的功能
（１)用C语言实现对N个进程采用动态优先权优先算法的进程调度；
（2)每个用来标识进程的进程控制块PCB用结构来描述,包括以下字段:
进程标识数;
进程优先数prioｒity，并规定优先数越大的进程,其优先权越高;
进程已占用的CPＵ时间cputｉme;
进程还需占用的ＣPU时间ａlltimｅ，当进程运行完毕时，allｔimｅ变为0;
ﻩｉｆ(i==0)／/如果创建的是第一个结点
ﻩﻩ｛
ﻩﻩheａd=temp1;
ห้องสมุดไป่ตู้ｈead-＞next=NUＬL；
coｎｔinue;
ﻩ}
ﻩﻩif(ｈead->priｏrｉty < temp1－>priority）/／如果创建结点中所保存的数比头结点所保存的数要大,则直接把该结点插入到头结点之前
ﻩﻩ｛
ｔｅmp１->neｘt=heａd；