循环算法，进程不完成执行

Question

我正在编写一个简单的 cpu 调度程序模拟器，目前我正在使用 Round Robin 算法。在这段代码中，我的实现方式是这样的：从用户输入中获取突发时间的总和以跟踪何时这个块应该完成。只要总和大于等于0，就继续执行。

现在，问题是总和变为负数，并且在进程的突发时间变为全 0 之前块停止执行。有什么办法可以解决这个问题吗？

例如，假设在我们的例子中我们的输入是{9, 12, 1, 1, 4, 4}，使用量程 4 执行所有进程后，阶段 1 的输出为：（其中第一列是原始数组，第二列是按量子值递减的）

sum: 31

phase nr: 1
9 7     not zero
12 10   not zero
1 0     check
1 0     check
4 2     not zero
4 2     not zero

phase nr: 2
7 5     not zero
10 8    not zero
0 0     check
0 0     check
2 0     check
2 0     check

在此阶段sum变为负数并停止打印其他进程

这是我到目前为止一直在使用的代码。我不知道这个解释是否足够清楚，我尽量做到清楚和具体。

注意：所有作业的到达时间都是 0

int[] a = {9, 12, 1, 1, 4, 4};
        int sum = 0;

        //total sum of the a[]
        for (int i = 0; i < a.length; i++) 
        {
            sum += a[i];            
        }
        System.out.printf("\nsum: %d\n\n", sum);

        int counter = 1;
        while(sum >= 0)
        {
            System.out.printf("\nphase nr: %d\n", counter);

            for (int i = 0; i < a.length; i++) 
            {
                //prints the original array
                System.out.printf("%d ",a[i]);
                int value = a[i]; //takes a value from a[] at index i
                value -= 2;      //decrement the value by quantum 2
                a[i] = value;   //put the value at the same index
                if (a[i] < 0)  //it checks if any element is less than 0, if yes replace it with 0
                {
                    a[i] = 0;
                }

                /**
                 *prints the array after subtracting 2 from each element 
                 *in the original array and checks if there is any value
                 *equal to 0, if yes print "check" else "not zero"
                 */
                System.out.printf("%d \t%s",a[i], a[i]==0?"check":"not zero");
                System.out.println();
            }

            /**
             * decrements the sum based on the quantum 
             * multiplied by processes 
             * sum = sum -(quantum * numberOfProcesses)
             */
            sum = sum - (4 * 6);

            counter++;
        }

Answer 1

问题在于计算总和。

sum = sum - (4 * 6);

您在每次迭代中减去 24，即使流程较早完成（例如在 1 个时间量内）或已经完成。

你应该在每次迭代中从sum中减去实际处理所花费的总时间。因此，如果过程完成 (a[i] == 0)，则您不会继续，如果 a[i] < 4，则减去该值。只有当 a[i] >=4 你应该减去 4 个量子。

如果你想为每个进程花费 4 个时间量而不考虑它的实际需求，无论它是否完成，那么你计算的总和是错误的，这不是真正的循环。

同时（总和 >= 0） { System.out.printf("\n相位编号: %d\n", counter);

        for (int i = 0; i < a.length; i++) 
        {
            //prints the original array
            System.out.printf("%d ",a[i]);
            int value = a[i]; //takes a value from a[] at index i
            if(a[i] == 0) { continue;} // skip process if it's done
            else if(a[i]<=4) { sum -=a[i]; a[i]=0;} // if process is less than one quantum then it's done and sum is decreased by time needed
            else { sum -=4; a[i] -=4} // otherwise process needs more than one quantum so it uses up all 4

            /**
             *prints the array after subtracting 2 from each element 
             *in the original array and checks if there is any value
             *equal to 0, if yes print "check" else "not zero"
             */
            System.out.printf("%d \t%s",a[i], a[i]==0?"check":"not zero");
            System.out.println();
        }
        // this part was completely unnecessary so it was removed to for loop above

        counter++;
    }

Answer 2

我不确定是否完全理解您的算法，但是总和的计算不正确。您应该定义一些函数来对数组 a[] 中的实际值求和，而不是进行一些错误的常量计算（您使用 4 作为量子而不是 2），并忽略一些 a 在设置为 0 后不会递减的事实.

你可以这样定义：

public static int totalBurstTime(int[] bursts) {
    int total = 0;
    for (int b : bursts) {
        total += b;
    }
    return total;
}

并在 while 循环之前调用它来初始化总和，然后在每个循环结束时调用它来初始化总和。

此外，你应该使用一些常量而不是幻数，例如

static final int QUANTUM = 2;

并在任何需要的地方使用它...

循环算法，进程不完成执行

Round Robin Algorithm, processes dont finish executing

java

algorithm

cpu

scheduler

round-robin