java - RoundRobin Java：基于循环算法的执行过程不发生

Question

我在这里遇到了一个问题：当前一个进程执行时间完全完成时，下一个进程才被执行。我需要这个过程基于循环算法执行。谁能给我提示如何为双处理器编写

    import java.util.Scanner;
public class RoundRobin {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
    Scanner keyboard = new Scanner(System.in);
    System.out.println("Enter the number of processes");
    int noProcess= keyboard.nextInt();
    int[][] process = new int[noProcess][3]; //1st column: process name, 2nd column: arrival time, 3rd column: execution time
    System.out.println("Input the Arrival and Execution Time for each process\n"); //in seconds, arrival for each process
    for(int i = 0; i < process.length ;i++)
        {
                process[i][0] = i+1;
                System.out.print("Process " +process[i][0]+ " :\t");
                System.out.print("Arrival Time : ");
                process[i][1] = keyboard.nextInt();
                System.out.print("\t\tExec. Time : ");  
                process[i][2] = keyboard.nextInt();
        }
    //sorting the processes based on arrival time
        for(int index = 0; index< process.length; index++ )
        {
          int indexOfNextSmallest = RoundRobin.getIndexOfSmallest(index, process);
          interchange(index, indexOfNextSmallest, process);   

        }
        System.out.println("ProName\tArrTime\tExecTime"); //table after scheduled.
        for(int row = 0; row < noProcess; row++)
        {
                for(int column = 0; column < 3; column++)
                {
                        System.out.print("" +process[row][column]+ "\t");
                }
                System.out.println("\n");
        }
        System.out.print("Enter the Quantum time:"); //in seconds
        int qTime = keyboard.nextInt();
       // boolean counter = true;//false if all process is completely execute
        /**while(counter)
        {


        }**/
       int current =0;
       int counter = qTime;
       int arrTime = 0;
       int index = 0;
       while(true)
       {

           if(process[index][2] >= qTime)
           {
               process[index][2] =  process[index][2]- qTime;
               counter = counter + qTime;
               System.out.println("Process" +process[index][0]);
           }
           if(process[index][2] != 0 && process[index][2] < qTime )
           {
               process[index][2] =  process[index][2] - process[index][2];
               counter = counter + process[index][2];
               System.out.println("Process" +process[index][0]);
           }

          boolean condition = true;
          int i = 0;
          while(condition)//check any uncompleted process
          {
              if(i == process.length){
                  System.out.println("All Process Executions are completed");
                  System.exit(0);}
              else if(process[i][2] == 0)
              {        
                i++;
              }
              else
              {
                 if(index < process.length-1)
                  {
                    if(counter >= process[index+1][1] )
                    {   index = index + 1;}
                    else
                    {   index = 0;}
                  }
                  else
                    {  index = 0;}

                    condition = false;
                }
          }

       }


// TODO code application logic here
    }

    private static int getIndexOfSmallest(int startIndex, int[][] a) {
        int min = a[startIndex][1];
        int indexOfMin = startIndex;
        for(int index = startIndex+1; index <a.length; index++)
        {
            if(a[index][1] < min)
            {
                min = a[index][1];
                indexOfMin = index;
            }
        }
        return indexOfMin;
    }
    private static void interchange(int i, int j, int[][] a)
    {
        int temp0 = a[i][0];
        int temp1 = a[i][1];
        int temp2 = a[i][2];
        a[i][0] = a[j][0];
        a[i][1] = a[j][1];
        a[i][2] = a[j][2];
        a[j][0] = temp0;
        a[j][1] = temp1;
        a[j][2] = temp2;
    }
}

JAva 代码文件：https ://skydrive.live.com/redir?resid=45E9B19710622F21!107 执行期间的图像：https ://skydrive.live.com/redir?resid=45E9B19710622F21!108

Answer 1

你需要的是一个简单的清单。循环很容易实现为列表。只需从列表的前面删除，然后将其放在后面。

ArrayList<Task> tasksToExecute = new ArrayList<Task>();
//  some code here that populates the list the first time

while (needToWork)
{
    Task nextTask = tasksToExecute.remove(0); // get the first object
    // process the task here
    tasksToExecute.add(nextTask);  // put the task back on the list
}

这将均匀处理列表中的所有任务。

Answer 2

这是我在 Java 中的大学项目。它显示了 CPU 如何接收每个进程。我在法国，这就是为什么它是法语：

import java.util.Scanner;

public class Round {
    int[] t = new int[26];
    int[] ta = new int[26];
    Scanner scan = new Scanner(System.in);
    String lettres = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String[] nom = lettres.split("");

    public void robin_sta() {
        /**
         * @author Etudiantcci Si les processus arrivent tous en même temps
         */
        System.out.println("\nRound Robin sans temps d'arrivée\n");
        int nbproc;
        int att = 0;
        do {
            System.out.print("Combien de processus (entre 1 et 26)? ");
            nbproc = scan.nextInt();
            if (nbproc <= 0 || nbproc > 26) {
                att++;
                if (att == 3) {
                    System.out.println("\nAu revoir!");
                    return;
                }
                System.out.println("\nChoisisez un entier entre 1 et 26, s'il-vous-plaît");
            }
        } while (nbproc <= 0 || nbproc > 26);

        att = 0;
        int q;
        System.out.println();
        do {
            System.out.print("Quantum s'il-vous-plaît: ");
            q = scan.nextInt();
            if (q <= 0) {
                att++;
                if (att == 3) {
                    System.out.println("\nAu revoir!");
                    return;
                }
                System.out.println("\nChoisisez un entier supérieur à 0, s'il-vous-plaît");
            }
        } while (q <= 0);
        for (int i = 0; i < nbproc; i++) {
            System.out.print("Rentrez la taille du processus " + nom[i + 1]
                    + ": ");
            t[i] = scan.nextInt();
            if (t[i] < 0) {
                System.out.println("\nValeurs positives s'il vous plaît!\n");
                System.out.print("Rentrez la taille du processus " + nom[i + 1]
                        + ": ");
                t[i] = scan.nextInt();
                if (t[i] < 0) {
                    System.out
                            .println("\nValeurs positives s'il vous plaît!\n");
                    System.out.print("Rentrez la taille du processus "
                            + nom[i + 1] + ": ");
                    t[i] = scan.nextInt();
                    if (t[i] < 0) {
                        System.out.println("\nVous comprenez rien!");
                        return;
                    }
                }
            }
            System.out
                    .print("Processus " + nom[i + 1]
                            + " (taille,temps d'arrivée): (" + t[i] + ","
                            + ta[i] + ")");
            System.out.println("\n");
        }

        /**
         * @author Etudiantcci Mise en place des outils pour la méthode
         */

        int[] t1 = new int[nbproc];
        int[] ta1 = new int[nbproc];
        int[] fil = new int[nbproc];
        int[] t2 = new int[nbproc];
        int[] t3 = new int[nbproc];
        int[] temps = new int[nbproc];
        int[] rot = new int[nbproc];

        for (int i = 0; i < nbproc; i++)
            t1[i] = t[i];
        for (int i = 0; i < nbproc; i++)
            ta1[i] = ta[i];

        int t = 0;
        for (int i : t1)
            t += i;
        String[] tab = new String[t];

        int s = ta1[0];
        for (int i : ta1)
            if (i < s)
                s = i;
        int k = 0;
        int j = 0;
        if (t1[0] == 0)
            for (int i = 0; i < nbproc; i++)
                if (t1[i] > 0) {
                    j = i;
                    break;
                }
        int port = 0;

        while (k < t) {
            for (int i = 0; i < nbproc; i++)
                if (ta1[i] == s) {
                    t2[i] = t1[i];
                    temps[i] = 1;
                    fil[i] = 1;
                }
            for (int i = 0; i < nbproc; i++)
                if (i != j && fil[i] == 1)
                    t3[i]++;
            fil[j] = 0;
            int cpt = 0;
            for (int i : t2)
                if (i > 0)
                    cpt++;
            if (cpt > 0) {
                if (port > 0) {
                    /**
                     * @author Etudiantcci Après un certain temps sans processus
                     *         exécutés, on détermine le prochain à exécuter dès
                     *         qu'il arrive
                     */
                    j = next_job(ta1, t2, j, s, t3);
                    port = 0;
                }
                int p = 0;
                while (p < q) {
                    /**
                     * @author Etudiantcci Calcul des temps d'attente
                     */
                    for (int i = 0; i < nbproc; i++)
                        if (i != j && temps[i] > 0 && t2[i] > 0)
                            temps[i]++;
                    tab[k] = nom[j + 1];
                    t2[j]--;
                    k++;
                    p++;
                    s++;
                    if (t2[j] == 0)
                        break;
                    /**
                     * @author Etudiantcci Si le processus se termine, on sort
                     *         de la boucle et on réinitialise le compteur du
                     *         quantum
                     */
                    for (int i = 0; i < nbproc; i++)
                        if (ta1[i] == s) {
                            t2[i] = t1[i];
                            temps[i] = 1;
                            fil[i] = 1;
                        }
                    /**
                     * @author Etudiantcci On donne plus de priorité aux
                     *         processus qui sont déjà dans la file d'attente
                     */
                    for (int i = 0; i < nbproc; i++)
                        if (i != j && fil[i] == 1)
                            t3[i]++;
                }
                if (t2[j] > 0)
                    fil[j] = 1;
                t3[j] = 0;
                for (int i = 0; i < nbproc; i++)
                    if (ta1[i] == s) {
                        t2[i] = t1[i];
                        temps[i] = 1;
                        fil[i] = 1;
                    }
                for (int i = 0; i < nbproc; i++)
                    if (i != j && fil[i] == 1)
                        t3[i]++;
                /**
                 * @author Etudiantcci Calcul du temps de rotation
                 */
                if (t2[j] == 0)
                    rot[j] = s - ta1[j];
                j = next_job(ta1, t2, j, s, t3);
                fil[j] = 0;
                t3[j] = 0;
            } else {
                s++;
                port++;
            }
        }

        System.out.print("\n * * Interprétation du processeur * *\n\n\t");
        affiche_tab(tab);
        System.out.println("\t");

        System.out.println("\n * * * Temps d'attente * * *");
        for (int i = 0; i < nbproc; i++) {
            System.out.print("\t" + nom[i + 1] + " --> ");
            if (temps[i] > 0)
                System.out.println(temps[i] - 1);
            else
                System.out.println(0);
        }

        System.out.print("\n * * Temps d'attente moyen * *\n\t");
        int m = 0;
        for (int i : temps)
            if (i > 0)
                m += i - 1;
        System.out.println((double) m / nbproc);

        System.out.println("\n * * * Temps de rotation * * *");
        for (int l = 0; l < nbproc; l++) {
            System.out.print("\t" + nom[l + 1] + " --> ");
            System.out.println(rot[l]);
        }

        System.out.println("\n * * Temps de rotation moyen * *");
        m = 0;
        for (int z : rot)
            m += z;
        System.out.println("\t" + (double) m / nbproc);

        System.out.println("\n * * Durée de l'exécution * *");
        System.out.println("\t" + s);
    }

    /**
     * @author Etudiantcci Pour déterminer le prochain processus à exécuter
     */

    private int next_job(int[] ta1, int[] t2, int j, int s, int[] t3) {
        int cpt = 0;
        int n = 0;
        for (int i = 0; i < t2.length; i++)
            if (t2[i] > 0) {
                cpt++;
                n = i;
            }
        if (cpt == 1)
            return n;
        else {
            cpt = 0;
            for (int k = 0; k < t2.length; k++)
                if (k != j && t2[k] > 0 && t3[k] == max(t3))
                    cpt++;
            if (cpt > 0)
                for (int k = 0; k < t2.length; k++)
                    if (k != j && t2[k] > 0 && t3[k] == max(t3))
                        return k;
            return j;
        }
    }

    /**
     * @author Etudiantcci Pour trouver la valeur maximale dans un tableau. On
     *         se sert pour déterminer le prochain proccesus à exécuter parmi
     *         ceux qui sont dans la file d'attente
     */

    private int max(int[] t3) {
        int max = t3[0];
        for (int i : t3)
            if (i > max)
                max = i;
        return max;
    }

    /**
     * @author Etudiantcci Pour afficher l'ordre d'exécution des processus
     */

    private void affiche_tab(String[] tab) {
        for (String i : tab)
            System.out.print(" " + i);
    }

    /**
     * @author Etudiantcci Pour déterminer le premier processus à exécuter
     */

    private int first_job(int[] ta1, int[] t1) {
        int ta_min = ta1[0];
        int t = 0;
        int[] n = new int[ta1.length];
        int[] m = new int[ta1.length];
        for (int i = 0; i < n.length; i++)
            if (ta1[i] < ta_min)
                ta_min = ta1[i];
        for (int i = 0; i < n.length; i++)
            if (ta1[i] == ta_min)
                n[i] = ta_min + 1;
        for (int i = 0; i < n.length; i++)
            if (n[i] == ta_min + 1)
                m[i] = t1[i];
        int k = min_positif(m);
        for (int i = 0; i < t1.length; i++)
            if (ta_min == ta1[i] && k == t1[i])
                t = i;
        return t;
    }

    /**
     * @author Etudiantcci Pour retrouver la plus petite valeur strictement
     *         positive
     */

    public int min_positif(int[] ar) {
        int min = -1;
        for (int i : ar)
            if (i > 0) {
                min = i;
                break;
            }
        if (min == -1) {
            System.out.println("\nPas de valeurs positives");
            return min;
        }
        for (int i : ar)
            if (i < min && i > 0)
                min = i;
        return min;
    }

    /**
     * @author Etudiantcci Pour retrouver l'indice de la plus petite valeur
     *         positive dans un tableau
     */

    public int ind_min_positif(int[] ar) {
        int min = min_positif(ar);
        int k = 0;
        for (int i = 0; i < ar.length; i++)
            if (ar[i] == min)
                k = i;
        return k;
    }

    public void robin_ta() {
        /**
         * @author Etudiantcci Si les processus arrivent à différents instants
         */
        System.out.println("\nRound Robin avec temps d'arrivée\n");
        int nbproc;
        int att = 0;
        do {
            System.out.print("Combien de processus (entre 1 et 26)? ");
            nbproc = scan.nextInt();
            if (nbproc <= 0 || nbproc > 26) {
                att++;
                if (att == 3) {
                    System.out.println("\nAu revoir!");
                    return;
                }
                System.out.println("\nChoisisez un entier entre 1 et 26, s'il-vous-plaît");
            }
        } while (nbproc <= 0 || nbproc > 26);

        att = 0;
        int q;
        System.out.println();
        do {
            System.out.print("Quantum s'il-vous-plaît: ");
            q = scan.nextInt();
            if (q <= 0) {
                att++;
                if (att == 3) {
                    System.out.println("\nAu revoir!");
                    return;
                }
                System.out.println("\nChoisisez un entier supérieur à 0, s'il-vous-plaît");
            }
        } while (q <= 0);

        for (int i = 0; i < nbproc; i++) {
            System.out.print("\nTaille du processus " + nom[i + 1] + "? ");
            t[i] = scan.nextInt();
            if (t[i] < 0) {
                System.out.println("\nValeurs positives s'il vous plaît!\n");
                System.out.print("\nTaille du processus " + nom[i + 1] + "? ");
                t[i] = scan.nextInt();
                if (t[i] < 0) {
                    System.out
                            .println("\nValeurs positives s'il vous plaît!\n");
                    System.out.print("\nTaille du processus " + nom[i + 1]
                            + "? ");
                    t[i] = scan.nextInt();
                    if (t[i] < 0) {
                        System.out.println("\nAu revoir");
                        return;
                    }
                }
            }
            System.out.print("Rentrez son temps d'arrivée: ");
            ta[i] = scan.nextInt();
            if (ta[i] < 0) {
                System.out.println("\nValeurs positives s'il vous plaît!\n");
                System.out.print("Rentrez son temps d'arrivée: ");
                ta[i] = scan.nextInt();
                if (ta[i] < 0) {
                    System.out
                            .println("\nValeurs positives s'il vous plaît!\n");
                    System.out.print("Rentrez son temps d'arrivée: ");
                    ta[i] = scan.nextInt();
                    if (ta[i] < 0) {
                        System.out.print("\nAu revoir!");
                        return;
                    }
                }
            }
            System.out.print("Processus " + nom[i + 1]+" (taille,temps d'arrivée): (" + t[i] + ","
                            + ta[i] + ")");
            System.out.println();
        }

        int[] t1 = new int[nbproc];
        int[] ta1 = new int[nbproc];
        int[] fil = new int[nbproc];
        int[] temps = new int[nbproc];
        int[] rot = new int[nbproc];

        for (int i = 0; i < nbproc; i++)
            t1[i] = t[i];
        for (int i = 0; i < nbproc; i++)
            ta1[i] = ta[i];

        int t = 0;
        for (int i : t1)
            t += i;
        String[] tab = new String[t];

        int s = ta1[0];
        for (int i : ta1)
            if (i < s)
                s = i;
        int k = 0;
        int[] t2 = new int[nbproc];
        int[] t3 = new int[nbproc];
        int j = first_job(ta1, t1);
        if (t1[0] == 0)
            for (int i = 0; i < nbproc; i++)
                if (t1[i] > 0) {
                    j = i;
                    break;
                }
        int port = 0;

        while (k < t) {
            for (int i = 0; i < nbproc; i++)
                if (ta1[i] == s) {
                    t2[i] = t1[i];
                    temps[i] = 1;
                    fil[i] = 1;
                }
            for (int i = 0; i < nbproc; i++)
                if (i != j && fil[i] == 1)
                    t3[i]++;
            fil[j] = 0;
            int cpt = 0;
            for (int i : t2)
                if (i > 0)
                    cpt++;
            if (cpt > 0) {
                if (port > 0) {

                    /**
                     * Après un certain temps sans processus exécutés, on
                     * détermine le prochain à exécuter dès qu'il arrive
                     */
                    j = next_job(ta1, t2, j, s, t3);
                    port = 0;
                }
                int p = 0;
                while (p < q) {
                    /**
                     * @author Etudiantcci Calcul des temps d'attente
                     */
                    for (int i = 0; i < nbproc; i++)
                        if (i != j && temps[i] > 0 && t2[i] > 0)
                            temps[i]++;
                    tab[k] = nom[j + 1];
                    t2[j]--;
                    k++;
                    p++;
                    s++;
                    if (t2[j] == 0)
                        break;
                    /**
                     * @author Etudiantcci Si le processus se termine, on sort
                     *         de la boucle et on réinitialise le compteur du
                     *         quantum
                     */
                    for (int i = 0; i < nbproc; i++)
                        if (ta1[i] == s) {
                            t2[i] = t1[i];
                            temps[i] = 1;
                            fil[i] = 1;
                        }
                    /**
                     * @author Etudiantcci On donne plus de priorité aux
                     *         processus qui sont déjà dans la file d'attente
                     */
                    for (int i = 0; i < nbproc; i++)
                        if (i != j && fil[i] == 1)
                            t3[i]++;
                }
                if (t2[j] > 0)
                    fil[j] = 1;
                t3[j] = 0;
                for (int i = 0; i < nbproc; i++)
                    if (ta1[i] == s) {
                        t2[i] = t1[i];
                        temps[i] = 1;
                        fil[i] = 1;
                    }
                for (int i = 0; i < nbproc; i++)
                    if (i != j && fil[i] == 1)
                        t3[i]++;
                /**
                 * @author Etudiantcci Calcul du temps de rotation
                 */
                if (t2[j] == 0)
                    rot[j] = s - ta1[j];
                j = next_job(ta1, t2, j, s, t3);
                fil[j] = 0;
                t3[j] = 0;
            } else {
                s++;
                port++;
            }
        }

        System.out.print("\n * * Interprétation du processeur * *\n\n\t");
        affiche_tab(tab);
        System.out.println("\t");

        System.out.println("\n * * * Temps d'attente * * *");
        for (int i = 0; i < nbproc; i++) {
            System.out.print("\t" + nom[i + 1] + " --> ");
            if (temps[i] > 0)
                System.out.println(temps[i] - 1);
            else
                System.out.println(0);
        }

        System.out.print("\n * * Temps d'attente moyen * *\n\t");
        int m = 0;
        for (int i : temps)
            if (i > 0)
                m += i - 1;
        System.out.println((double) m / nbproc);

        System.out.println("\n * * * Temps de rotation * * *");
        for (int l = 0; l < nbproc; l++) {
            System.out.print("\t" + nom[l + 1] + " --> ");
            System.out.println(rot[l]);
        }

        System.out.println("\n * * Temps de rotation moyen * *");
        m = 0;
        for (int z : rot)
            m += z;
        System.out.println("\t" + (double) m / nbproc);

        System.out.println("\n * * Durée de l'exécution * *");
        System.out.println("\t" + s);
    }

}