在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，为了使系统中的进程有条不紊地工作，必须选用某种调度策略，在一定的时机选择一个进程占有处理机。要求设计一个模拟处理机调度算法，以巩固和加深处理机调度的概念。
设计要求
每一个进程有一个PCB ，其内容可以根据具体情况设定。进程数、进入内存时间、要求服务时间、进程大小、优先级等可以通过在界面上设定，也可读取样例数据进行初始化。
进程调度算法包括：先来先服务算法、短进程优先算法、静态优先权优先调度算法、高响应比调度算法、时间片轮转算法
可比较同一组数据在不同调度算法下的平均等待时间、平均周转时间、平均带权周转时间。
代码实现：
-
PCB类：
public class PCB {
/*设计要求
* 每一个进程有一个PCB ，其内容可以根据具体情况设定
* 进程数、进入内存时间、要求服务时间、进程大小、优先级等可以通过在界面上设定，
* 也可读取样例数据（要求存放在外部文件中）进行初始化。
*/
private String name;//进程名
private int arr_time;//进入内存时间
private int run_time;//要求服务时间
private int wait_time;//等待时间
private double c_time;//周转时间
private int pri;//优先权
private double response;//响应比
private char sta;//状态
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getArr_time() {
return arr_time;
}
public void setArr_time(int arr_time) {
this.arr_time = arr_time;
}
public int getRun_time() {
return run_time;
}
public void setRun_time(int run_time) {
this.run_time = run_time;
}
public int getWait_time() {
return wait_time;
}
public void setWait_time(int wait_time) {
this.wait_time = wait_time;
}
public double getC_time() {
return c_time;
}
public void setC_time(double c_time) {
this.c_time = c_time;
}
public int getPri() {
return pri;
}
public void setPri(int pri) {
this.pri = pri;
}
public double getResponse() {
return response;
}
public void setResponse(double response) {
this.response = response;
}
public char getSta() {
return sta;
}
public void setSta(char sta) {
this.sta = sta;
}
public PCB(String name, int arr_time, int run_time, int wait_time, double c_time, int pri, double response,
char sta) {
super();
this.name = name;
this.arr_time = arr_time;
this.run_time = run_time;
this.wait_time = wait_time;
this.c_time = c_time;
this.pri = pri;
this.response = response;
this.sta = sta;
}
public PCB() {
super();
// TODO 自动生成的构造函数存根
}
@Override
public String toString() {
return "PCB [name=" + name + ", arr_time=" + arr_time + ", run_time=" + run_time + ", wait_time=" + wait_time
+ ", c_time=" + c_time + ", pri=" + pri + ", response=" + response + ", sta=" + sta + "]";
}
}
-
算法测试类：
import java.util.Scanner;
// org.springframework.beans.BeanUtils;
/**
* 1、通用处理机调度演示程序的实现
在多道程序和多任务系统中，系统内同时处于就绪状态的进程可能有若干个，
为了使系统中的进程有条不紊地工作，必须选用某种调度策略，在一定的时机选择一个进程占有处理机。
要求学生设计一个模拟处理机调度算法，以巩固和加深处理机调度的概念。
* @author Liuhuimin
*
*/
public class Test {
/*设计要求
* 进程调度算法包括
* 先来先服务算法、短进程优先算法、静态优先权优先调度算法、高响应比调度算法、时间片轮转算法
* （选择至少三种算法进行实现）。*/
static int c=10000;
static int late=0;
static int longtime=0;
static int highpri=0;
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入进程数量：");
int Pnum=sc.nextInt();
//PCB [] pcb=new PCB[Pnum];
PCB [] test=new PCB[Pnum];
intal_pcb(test);
System.out.println("您的设定结果如下：");
print(test);
//test=(PCB[])pcb.clone();
//BeanUtils.copyProperties(pcb, test);
System.out.println("开始为进程调度算法：");
FCFS(test);//先来先服务
Prepare(test);
//print(pcb);
intal_pcb(test);
//test=pcb.clone();;
SJF(test);//短作业优先
Prepare(test);
intal_pcb(test);
//test=pcb.clone();;
HPF(test);//优先权高者优先
Prepare(test);
intal_pcb(test);
//test=pcb.clone();;
HRRN(test);//响应比高者优先
Prepare(test);
}
public static void intal_pcb(PCB[] pcb) {
Scanner sc=new Scanner(System.in);
// int [] arr_time= {800,815,830,835,845,700,820};//进入内存时间
// int [] run_time= {50,30,25,20,15,10,5};//要求服务时间
// int [] pri= {0,1,2,3,4,1,0};//优先权
for(int i=0;i<pcb.length;i++) {
pcb[i]=new PCB();
pcb[i].setName((i+1)+"");
System.out.println("请输入第"+(i+1)+"个进程的进入内存时间：");
int arr_time=sc.nextInt();
pcb[i].setArr_time(arr_time);
if(c>arr_time)//设置当前时间（最小进入内存时间）
{c=arr_time;}
if(late<arr_time)//最迟进入内存时间
{late=arr_time;}
System.out.println("请输入第"+(i+1)+"个进程的要求服务时间：");
int run_time=sc.nextInt();
pcb[i].setRun_time(run_time);
if(longtime<run_time)//最迟进入内存时间
{longtime=run_time;}
System.out.println("请输入第"+(i+1)+"个进程的优先权：");
int pri=sc.nextInt();
pcb[i].setPri(pri);
if(highpri<pri)//最高优先权
{highpri=pri;}
pcb[i].setSta('W');
}
}
//输出
public static void print(PCB[]pcb) {
for(int i=0;i<pcb.length;i++) {
System.out.println(pcb[i]);
}
System.out.println();
}
//判断是否全部完成
private static boolean fun(PCB[] pcb) {
for(int i=0;i<pcb.length;i++) {
if(pcb[i].getSta()!='F') {
return true;
}
}
return false;
}
/*设计要求
* 有性能比较功能，可比较同一组数据在不同调度算法下的平均等待时间、平均周转时间、平均带权周转时间。*/
//比较
public static void Prepare(PCB [] pcb) {
double wait=0;double ct=0;double wait_ct;
for(int i=0;i<pcb.length;i++) {
wait=pcb[i].getWait_time()+wait;
ct=pcb[i].getC_time()+ct;
}
wait=wait/7;//平均等待时间=等待时间/进程数
ct=ct/7;//平均周转时间=周转时间/进程数
wait_ct=wait/ct;//平均带权周转时间=平均等待时间/平均周转时间
System.out.println("平均等待时间："+wait+" 平均周转时间："+ct+"平均带权周转时间："+wait_ct);
}
//先来先服务（First-Come First-Served，FCFS）调度算法
//按作业到达的先后次序进行调度。总是首先调度在系统中等待时间最长的作业。
public static void FCFS(PCB [] pcb) {
System.out.println("-------FCFS------");
while(fun(pcb)) {
int max=late;
int min_i=-1;
for(int i=0;i<pcb.length;i++) {
if(pcb[i].getArr_time()<=c&&pcb[i].getSta()!='F') {
//if(到达时间<=本轮开始时间)
if(pcb[i].getArr_time()<=max) {
max=pcb[i].getArr_time();
min_i=i;//作业排序
}
}
}
if(min_i==-1) {
c+=1;
}else {
pcb[min_i].setSta('R');
pcb[min_i].setWait_time(c-pcb[min_i].getArr_time());
print(pcb);//输出R的情况
c=c+pcb[min_i].getRun_time();
//System.out.println("c："+c);
pcb[min_i].setSta('F');
pcb[min_i].setC_time(c-pcb[min_i].getArr_time());
print(pcb);//输出F的情况
}
}
}
//短作业优先 (Shortest-Job-First，SJF) 调度算法
//优先调度要求运行时间最短的作业。
public static void SJF(PCB [] pcb) {
System.out.println("-------SJF------");
while(fun(pcb)) {
int min=longtime;
int min_i=-1;
for(int i=0;i<pcb.length;i++) {
if(pcb[i].getArr_time()<=c&&pcb[i].getSta()!='F') {
if(pcb[i].getRun_time()<=min) {
min=pcb[i].getRun_time();
min_i=i;//作业排序
}
}
}
if(min_i==-1) {
c+=1;
}else {
pcb[min_i].setSta('R');
pcb[min_i].setWait_time(c-pcb[min_i].getArr_time());
print(pcb);//输出R的情况
c+=pcb[min_i].getRun_time();
pcb[min_i].setSta('F');
pcb[min_i].setC_time(c-pcb[min_i].getArr_time());
print(pcb);//输出F的情况
min_i=-1;
}
}
}
//优先权高者优先（Highest-Priority-First，HPF）调度算法
//为每个作业设置一个优先数，优先数高者优先调度。
public static void HPF(PCB [] pcb) {
System.out.println("-------HPF------");
while(fun(pcb)) {
int min=highpri;
int min_i=-1;
for(int i=0;i<pcb.length;i++) {
if(pcb[i].getArr_time()<=c&&pcb[i].getSta()!='F') {
if(pcb[i].getPri()<=min) {
min=pcb[i].getPri();
min_i=i;//作业排序
}
}
}
if(min_i==-1) {
c+=1;//未开始 时间+1
}else {
pcb[min_i].setSta('R');
pcb[min_i].setWait_time(c-pcb[min_i].getArr_time());
print(pcb);//输出R的情况
c+=pcb[min_i].getRun_time();
pcb[min_i].setSta('F');
pcb[min_i].setC_time(c-pcb[min_i].getArr_time());
print(pcb);//输出F的情况
}
}
}
//计算响应比 响应比＝ 作业周转时间 / 作业运行时间，数值越大越优先。
public static double Response(int c,PCB [] pcb) {
for(int i=0;i<pcb.length;i++) {
if(pcb[i].getArr_time()<=c&&pcb[i].getSta()!='F') {
pcb[i].setResponse((c-pcb[i].getArr_time())/pcb[i].getRun_time());
}
}
//排序
PCB [] temp=new PCB[1];
for(int n=0;n<pcb.length-1;n++) {
for(int m=0;m<pcb.length-n-1;m++) {
//根据响应比
if(pcb[m+1].getResponse()<pcb[m].getResponse()) {
temp[0]=pcb[m];
pcb[m]=pcb[m+1];
pcb[m+1]=temp[0];
}
}
}
return pcb[pcb.length-1].getResponse();
}
//响应比高者优先（Highest Response Ratio Next，HRRN）调度算法
//计算每个作业的响应比，响应比＝ 作业周转时间 / 作业运行时间，数值越大越优先。
public static void HRRN(PCB [] pcb) {
System.out.println("-------HRRN------");
while(fun(pcb)) {
double max=Response(c,pcb);
int min_i=-1;
for(int i=0;i<pcb.length;i++) {
if(pcb[i].getArr_time()<=c&&pcb[i].getSta()!='F') {
if(pcb[i].getResponse()>=max) {
max=pcb[i].getResponse();//修改最高响应比
min_i=i;//作业排序
}
}
}
if(min_i==-1) {
c+=1;
}else {
pcb[min_i].setSta('R');
pcb[min_i].setWait_time(c-pcb[min_i].getArr_time());
print(pcb);//输出R的情况
c+=pcb[min_i].getRun_time();
pcb[min_i].setSta('F');
pcb[min_i].setC_time(c-pcb[min_i].getArr_time());
print(pcb);//输出F的情况
}
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
