Question

名为myArr的My Array包含

Process  burst  arrive
1         8      0
2         4      1
3         9      2
4         5      3

我遇到的问题是我认为我的Min（）方法出错并且我正在获得此输出

Gantt Chart
| p[2]  | p[4]  | p[1]  | p[3]  |
0       1       5      10      17   26

我应该得到以下输出

enter image description here

System.out.println("--------------------------------------Shortest Process Next--------------------------------------"); 
             System.out.println();

             Arrays.sort(myArr, new Comparator<int[]>() {
                    public int compare(int[] o1, int[] o2) {
                        int ret = Integer.compare(o1[2], o2[2]);
                        // if the entries are equal at index 2, compare index 1
                        if (0 == ret) {
                            ret = Integer.compare(o1[1], o2[1]);
                        }
                        return (ret);
                    }
                });

            System.out.println("____Process_____");
            System.out.println("P   "+"B  "+"A  ");
            for(int t=0; t<myArr.length; t++){


                System.out.println(myArr[t][0]+"  "+myArr[t][1]+"  "+myArr[t][2]+"  ");
            }


              InputStreamReader isr = new InputStreamReader(System.in);
                BufferedReader in = new BufferedReader(isr);

                int n=myArr.length; //# of process


                int p[] = new int[n];
                int at[] = new int[n];
                int bt[] = new int[n];
                int bt2[] = new int[n];
                int wt[] = new int[n];
                int tat[] = new int[n];

                for (int i = 0; i < n; i++) {

                    p[i] = myArr[i][0]; // Process number
                    at[i] = myArr[i][2]; //arrival time
                    bt[i] = myArr[i][1];//burst time

                    bt2[i] = bt[i];//copy of the burst times
                }

                int tbt = 0;
                for (int i = 0; i < n; i++) {
                    tbt = tbt + bt[i];              //Suma de todos los burst time
                }

                int time[] = new int[tbt]; // array time tiene un size del count de los burst time
                int k = 0;
                int q2 = 0;

                System.out.println("Gantt Chart");
                System.out.print("|");
                //bt[0] = bt[0] - 1;

                for (int i = 0; i < tbt; i++) {
                    int q = Min(bt, at, tbt, i, n);
                    if (q != q2) {
                        System.out.print(" p[" + p[q] + "]\t|");
                        time[k++] = i;
                        wt[q] = i;
                        tat[q] = i + bt[q];
                    }
                    bt[q] = bt[q] - 1;
                    q2 = q;
                }
                time[k] = tbt;
                System.out.println();
                System.out.print("0\t");
                for (int i = 0; i <= k; i++) {
                    System.out.print(time[i] + "\t");
                }

我觉得这个我的Min（）方法搞砸了我的输出

public static int Min(int b[], int a[], int tbt, int r, int n) { 

        int j = 0;
        int min = tbt;

        for (int i = n - 1; i >= 0; i--) {
            if (b[i] < min && b[i] > 0 && r >= a[i]) {
                min = b[i];
                j = i;
            }
        }
        return j;
    }

Answer 1

您需要按照到达时间安排此计划，而不是直接使用最短的剩余时间因素。

输出错误的原因是： -

除非进程已进入队列，否则无法将其安排在就绪队列中。
此外， 您的预期输出图表也显示不正确 。如果只是，需要首先实现最短的剩余时间，没有任何时间片，那么甘特图看起来像： -

| P1 | P2 | P4 | P3 |

    0            8     12      17              26

现在，我不会评论您的代码上的错误，因为它看起来很多，但是，我会建议您采用更好的方法。

a）您应首先检查每个流程的到达时间   0并首先选择最短的突发时间作业，让它完全执行。

b）完成第一份工作后，再次检查所有流程的到达时间，然后选择最短的突发时间流程（已到达的流程）

c）对n个进程进行迭代。选择最短的突发时间进程并完全完成，然后按照步骤a，b和c进行操作，直到进程结束。

如果您在实施相同问题时遇到问题，请提出一个与此相关的新问题。

最短剩余时间调度Min（）错误

1 个答案: