java最短作业优先算法_短作业优先调度算法（SJF）——
Java实现
短作业优先调度算法(SJF) 短作业优先调度算法(Short Job First)⽤于进程调度时⼜被称为短进程优先调度算法(Short Process First)，该算法既可以⽤于作业调度，⼜可以⽤于进程调度。
在作业调度中，该算法每次从后备作业队列中挑选估计服务时间最短的⼀个或⼏个作业，将他们调⼊内存，分配必要的资源，创建进程并放⼊就绪队列。在进程调度中的原理类似。
题⽬：
每个任务请求都以其请求时间(向系统提交请求的时间)和 其持续时间(即完成任务所需要的时间)为特征。
当前任务完成后，SJF 策略选择具有最短持续时间的任务作为下⼀个要执⾏的任务。如果多个任务都有最短持续时间，则选择请求时间最早的那个任务，任务的的等待时间为请求时间和时间开始时间的差值(即，等待系统执⾏任务所花的时间)。假设任务到达时系统时钟处于执⾏任务的状态，且永远不会关闭。
给定的⼀个请求时间和任务持续时间的列表，计算使⽤最短作业优先(SJF)算法调度时的平均等待时间。
所给出的请求时间和持续时间都是按照请求时间的升序排序的。
ShortFirstJob类，有⼀个⽅法minAgerageWaitTime(int[] requestTime, int[] durationTime) requestTime是n个任务的请求时
间，durationTime是n个任务的持续时间。该⽅法返回⼀个表⽰平均等待时间(使⽤⾮抢占式SJF调度算法)的浮点数。
(假定0 <= 到达时间 < 100.0 < 突发时间 < 100)
注：优先选择持续时间⼩的，如果持续时间相同，则选择请求时间早的。
提交时间 = 请求时间
服务时间 = 作业需要运⾏的时间，即持续时间
开始时间 = task == 0 ? 0 : 上个优选任务 完成时间
完成时间 = 开始时间 + 服务时间
等待时间 = 开始时间 - 提交时间
慎而无礼则葸
周转时间 = 完成时间 - 提交时间
带权周转时间 = 周转时间 / 服务时间
响应⽐ = (等待时间 + 服务时间) / 服务时间 = 等待时间/服务时间 + 1
fanxingpublic class ShortJobFirst {
public static float minAgerageWaitTime(int[] requestTime, int[] durationTime){
int length = requestTime.length;
int[] rviceTime = new int[length]; //服务时间 即是持续时间
for(int i=0; i
宝宝拍嗝rviceTime[i] = durationTime[i];
}
int[] task = new int[length]; //任务号
寂静的生活
for(int i=0; i
task[i] = i+1;
}
int[] waitTime = new int[length]; //等待时间
int[] startTime = new int[length]; //开始时间
int[] finishTime = new int[length]; //完成时间
int[] turnTime = new int[length]; //周转时间
float[] rightTurnTime = new float[length]; //带权周转时间
startTime[0] = requestTime[0];
finishTime[0] = startTime[0] + durationTime[0];
waitTime[0] = startTime[0] - requestTime[0];
turnTime[0] = finishTime[0] - requestTime[0];
rightTurnTime[0] =(float) turnTime[0] / durationTime[0];
System.out.println("11111:"+rightTurnTime[0]);
导盲犬迪克int minIndex = 0;
int lastIndex = 0;
int[] durations = getMin( requestTime,rviceTime); //得到任务调动的顺序
for(int i=1; i
minIndex = durations[i-1]+1;
startTime[minIndex] = finishTime[lastIndex]; //开始时间 = task == 0 ? 0 : 上个优选任务的完成时间
finishTime[minIndex] = startTime[minIndex] + durationTime[minIndex]; //完成时间 = 开始时间 + 服务时间
waitTime[minIndex] = startTime[minIndex] - requestTime[minIndex]; //等待时间 = 开始时间 - 提交时间
turnTime[minIndex] = finishTime[minIndex] - requestTime[minIndex]; //周转时间 = 完成时间 - 提交时间
rightTurnTime[minIndex] = (float)turnTime[minIndex] / durationTime[minIndex]; //带权周转时间 = 周转时间 / 服务时间lastIndex = minIndex; //将当前索引记为上⼀个任务索引
}
int add = 0;
float result;
for(int i=0; i< length; i++){
add += waitTime[i];
}
result = (float)add/length; //求平均等待时间
return result;
}
/**
* 得到任务调动的顺序
* @param requstTime
* @param durationTime
* @return
*/
private static int[] getMin(int[] requstTime, int[] durationTime) {
int length = durationTime.length;
int[] arr = new int[length-1]; //去除第⼀个任务，剩下的任务的服务时间
int[] arr1 = new int[length-1]; //存放剩下任务的开始顺序索引
int[] arr2 = new int[length-1]; //存放剩下任务的开始顺序值
for(int i=0; i
arr[i] = durationTime[i+1];
}
int minIndex =0;
for(int i=0; i
for(int j=0 ; j
30万的车
if(arr[j] < arr[minIndex]){
minIndex = j;
}
}
最大的货轮arr1[i] = minIndex;
arr2[i] = arr[minIndex];
arr[minIndex] = Integer.MAX_VALUE;
}
return arr1;
}
日本夏日祭
public static void main(String[] args) {
int[] requestTime = {0,1,2,3,4};
int[] durationTime = {4,3,5,2,4};
float averageWaitTime = ShortJobFirst.minAgerageWaitTime(requestTime, durationTime); System.out.println("平均等待时间：" + averageWaitTime );
}
