最短任务调度算法

Posted 2020-10-04 上后谈爱情

  1 package com.mmall.common.program;
  2 
  3 import java.util.Map;
  4 import java.util.Scanner;
  5 import java.util.TreeMap;
  6 
  7 /**
  8  * Created by Workstation on 2017/8/23.
  9  * 实现最短任务调度算法，求其中平均等待时间
 10  */
 11 public class SJB {
 12 
 13     public static void main (String[] args) {
 14       /*  Scanner sc=new Scanner (System.in);
 15 
 16         int N=sc.nextInt ();
 17 
 18         int Commitmatrix[]=new int[N];// 提交时间 从0开始进行排序
 19         int Service[]=new int[N];// 任务的服务时间
 20 
 21         for(int i=0;i<N;i++)
 22         {
 23             Commitmatrix[i]=sc.nextInt ();
 24         }
 25 
 26         for(int i=0;i<N;i++)
 27         {
 28             Service[i]=sc.nextInt ();
 29         }
 30     */
 31       int[] Commitmatrix={0,1,2,3,4};
 32       int N=5;
 33       int Service[]={4,3,5,2,4};
 34         Shorttask(Commitmatrix,Service,N);
 35     }
 36 
 37     private static void Shorttask (int[] Com, int[] Ser, int n) {
 38         int [] visited=new int[n];// 标记作业是否已经被调度过 ，从0-Com 时间中挑选最短任务
 39         double wait_time=0.0;
 40         int start_time=0;// 当前任务运行开始时间
 41         int cur=0;// 调度任务的下标
 42 
 43         Map<Integer,Integer> map=new TreeMap<> ();//
 44 
 45         int[] waitwork=new int[n]; int next=0;
 46         for(int i=0;i<n;i++)
 47         {
 48             wait_time+=Math.abs(start_time-Com[cur]); // 出现 Com>start_time
 49             start_time+=Ser[cur];//记录下一次调度开始时间
 50 
 51             visited[cur]=1;
 52 
 53             // 在 服务时间中挑选最短任务时间 j表示任务索引
 54             int num=0;
 55             for(int j=1;j<n;j++)
 56             {
 57                 if(visited[j]==0 && Com[j]<=start_time) // 将0-start_time 提交的任务记录下来
 58                 {
 59                     //map.put(Ser[j],j);
 60                     waitwork[num++]=j;
 61                 }
 62             }
 63 
 64             // 寻找最短的作业，注意map为空，提交时间> 服务时间，只能够
 65             if(num>0)
 66             {
 67                 next=getMintask(waitwork,num,Ser);
 68             }else // 就绪队列中没有任务，只能从挑选出下一个任务,相当于重新开始一样
 69             {
 70                 if(i+1<n)
 71                 {
 72                     next=i+1;
 73                     wait_time+=Math.abs(start_time-Com[next]);// 就绪队列NULL，向下添加新的任务，整个任务分隔成两个单独任务
 74                     start_time=Com[next];
 75                 }
 76 
 77 
 78             }
 79             cur=next;
 80         }
 81         System.out.println(wait_time/n);
 82     }
 83 
 84     private static int getMintask (int[] waitwork, int num,int[] Ser) {
 85         int min=Integer.MAX_VALUE;
 86         int next=0;
 87         if(num>0) // 队列中用于准备就绪任务，从其中挑选出最短任务时间
 88         {
 89             for(int k=0;k<num;k++)
 90             {
 91                 if(Ser[waitwork[k]]<min)
 92                 {
 93                     min=Ser[waitwork[k]];
 94                     next=waitwork[k];
 95                 }
 96             }
 97         }
 98         return next;
 99     }
100 }

/***
 *  ABCDEFG:0,1,2,3,4,15,16
 *  A-D-B-C-E-F-G: 
 *  4-2-3-5-15-16-17
 *  平均时间 0+4-3+6-1+9-2=13 等待时间
 *  开始时间执行到C之后没有就绪队列 4+2+3+5=14 下一个任务开始时间 15 中间等待时间13+1=14 ---之后相当于重新开始另外一个任务
 *  14+0+4-1+12-2=27 总的等待时间 27/7=3.85
 * */