Question

我需要实施＆＃34;循环赛＆＃34;具有我无法修改的作业类的调度程序。循环调度程序应该首先处理等待时间最长的作业，然后将计时器重置为零。如果两个作业具有相同的等待时间，则首先处理较低的ID。作业类只提供三个值（作业ID，剩余持续时间和优先级（此时不需要）。每个作业都有一个开始时间，因此在第一个周期中只有几个作业可用，下一个周期可能更少，因为每次打电话给我打电话的工作阵列都不一样，所以我不确定如何存储等待时间。

这是工作班：

public class Jobs{
private int[] stas = new int[0];
private int[] durs = new int[0];
private int[] lefs = new int[0];
private int[] pris = new int[0];
private int[] fins = new int[0];
private int clock;

public Jobs()
{
    this("joblist.csv");
}

public Jobs(String filename)
{
    BufferedReader fp = null;
    String line = "";
    String[] b = null;
    int[] tmp;
    try
    {
        fp = new BufferedReader(new FileReader(filename));
        while((line = fp.readLine()) != null)
        {
            b = line.split(",");
            if(b.length == 3)
            {
                try
                {
                    int sta = Integer.parseInt(b[0]);
                    //System.out.println("sta: " + b[0]);
                    int dur = Integer.parseInt(b[1]);
                    //System.out.println("dur: " + b[1]);
                    int pri = Integer.parseInt(b[2]);
                    //System.out.println("pri: " + b[2]);
                    stas = app(stas, sta);
                    //System.out.println("stas: " + Arrays.toString(stas));
                    durs = app(durs, dur);
                    //System.out.println("durs: " + Arrays.toString(durs));
                    lefs = app(lefs, dur);
                    //System.out.println("lefs: " + Arrays.toString(lefs));
                    pris = app(pris, pri);
                    //System.out.println("pris: " + Arrays.toString(pris));
                    fins = app(fins, -1);
                    //System.out.println("fins: " + Arrays.toString(fins));
                }
                catch(NumberFormatException e) {}
            }
        }
        fp.close();
    }
    catch(FileNotFoundException e) { e.printStackTrace(); }
    catch(IOException e) { e.printStackTrace(); }
    clock = 0;
}

public boolean done()
{
    boolean done = true;
    for(int i=0; done && i<lefs.length; i++)
        if(lefs[i]>0) done=false;
    return done;
}

public int getClock() { return clock; }
public int[][] getJobs()
{
    int count = 0;
    for(int i=0; i<stas.length; i++)
        if(stas[i]<=clock && lefs[i]>0)
            count++;
    int[][] jobs = new int[count][3];
    count = 0;
    for(int i=0; i<stas.length; i++)
        if(stas[i]<=clock && lefs[i]>0)
        {
            jobs[count] = new int[]{i, lefs[i], pris[i]};
            count++;
        }
    return jobs;
}

public int cycle() { return cycle(-1); }
public int cycle(int j)
{
    if(j>=0 && j<lefs.length && clock>=stas[j] && lefs[j]>0)
    {
        lefs[j]--;
        if(lefs[j] == 0) fins[j] = clock+1;
    }
    clock++;
    return clock;
}

private int[] app(int[] a, int b)
{
    int[] tmp = new int[a.length+1];
    for(int i=0; i<a.length; i++) tmp[i] = a[i];
    tmp[a.length] = b;
    return tmp;
}

public String report()
{
    String r = "JOB,PRIORITY,START,DURATION,FINISH,DELAY,PRI*DELAY\n";
    float dn=0;
    float pdn=0;
    for(int i=0; i<stas.length; i++)
    {
        if(fins[i]>=0)
        {
            int delay = ((fins[i]-stas[i])-durs[i]);
            r+= ""+i+","+pris[i]+","+stas[i]+","+durs[i]+","+fins[i]+","+delay+","+(pris[i]*delay)+"\n";
            dn+= delay;
            pdn+= pris[i]*delay;
        }
        else
        {
            int delay = ((clock*10-stas[i])-durs[i]);
            r+= ""+i+","+pris[i]+","+stas[i]+","+durs[i]+","+fins[i]+","+delay+","+(pris[i]*delay)+"\n";
            dn+= delay;
            pdn+= pris[i]*delay;
        }
    }
    if(stas.length>0)
    {
        r+= "Avg,,,,,"+(dn/stas.length)+","+pdn/stas.length+"\n";
    }
    return r;
}

public String toString()
{
    String r = "There are "+stas.length+" jobs:\n";
    for(int i=0; i<stas.length; i++)
    {
        r+= "  JOB "+i+": START="+stas[i]+" DURATION="+durs[i]+" DURATION_LEFT="+lefs[i]+" PRIORITY="+pris[i]+"\n";
    }
    return r;
}

我不需要完整的代码，只是想知道如何存储等待时间并循环正确的工作。

Answer 1

虽然基于阵列的解决方案可以＆＃39;工作，我会提倡更加面向对象的方法。创造＆＃39;工作＆＃39;具有欲望属性的类（id，start_time，wait等）。使用csv文件创建Job对象并将其保存在列表中。写一个比较器来排序这个作业列表（在这种情况下，基于作业等待/年龄将是因素）。

然后，作业执行者必须执行以下操作：

while(jobs exist) {
  iterate on the list {
    if job is executable // start_time > current sys_time
    consume cycles/job for executable jobs
    mark completed jobs (optional)
  }    
  remove the completed jobs
}

Answer 2

 //\ This loop will add +1 to each job
    for(int i = 0; i < jobs.length; i++)
    {
        waitTime[jobs[i][0]] += 1;          
    }

int longestWait = 0;//\ This holds value for greatest wait time
int nextJob = 0; //\ This holds value for index of job with greatest wait time

    //\ this loop will check for the greatest wait time and and set variables accordingly
    for(int i = 0; i < waitTime.length; i++)
    {
        if(waitTime[i] > longestWait)
    {
            longestWait = waitTime[i];
            nextJob = i;
    }
    }

    //\ this cycles the job with the highest wait time
    jobsource.cycle(nextJob);

    //\ this resets the wait time for processed job
    waitTime[nextJob] = 0;

Round Robin Scheduler

2 个答案: