1. java
  2. android
  3. c#
  4. .net
  5. javascript
  6. php
  7. jquery
  8. html
  9. sql

Como faço para criar um ArrayList com a linha de processamento de um escalonador Round Robin?

import java.util.ArrayList;

import javax.swing.JOptionPane;

import jeduardo.commom.Processo;

public class RoundRobin2 {
    int nroProcessos;
    int quantum;
    int trocaDeContexto;
    int somaTamanho;

    /**
     * Obter os valores basicos
     */
    public void getInfo() {

        // Coleta os valores iniciais
        nroProcessos = Integer.parseInt(JOptionPane
                .showInputDialog("Informe o numero de Processos: "));
        quantum = Integer.parseInt(JOptionPane
                .showInputDialog("Informe o valor do Quantum: "));
        trocaDeContexto = Integer
                .parseInt(JOptionPane
                        .showInputDialog("Informe o valor gasto com a troca de contexto: "));

        // Amazenar as informações de todos os processos
        Processo proc[] = new Processo[nroProcessos];

        // Armazena os processos em uma lista
        for (int i = 0; i < nroProcessos; i++) {

            proc[i] = new Processo();
            proc[i].setId(JOptionPane.showInputDialog("Informe o ID do "
                    + (i + 1) + "º processo."));

            proc[i].setMomentoChegada(Integer.parseInt(JOptionPane
                    .showInputDialog("Informe o momento de chegada " + (i + 1)
                            + "º processo.")));

            proc[i].setTamanho(Integer.parseInt(JOptionPane
                    .showInputDialog("Informe o tamanho " + (i + 1)
                            + "º processo.")));

        }
        // Chamar o metodo de execucao do escalonador RR
        execEscalonador(nroProcessos, quantum, proc);
    }

    /**
     * Executa o escalonador com as informações repassadas
     */
    public void execEscalonador(int nroProc, int quantum, Processo processo[]) {

        // Ordenar processos por ordem de momento de chegada
        for (int i = 0; i < processo.length - 1; i++) {
            for (int j = 0; j < processo.length - 1; j++) {
                if (processo[j].getMomentoChegada() > processo[j + 1]
                        .getMomentoChegada()) {
                    Processo auxiliar = processo[j];
                    processo[j] = processo[j + 1];
                    processo[j + 1] = auxiliar;
                }
            }
        }

        int particoes[] = new int[nroProc];

        // Quebrar processos em particoes de processamento
        for (int p = 0; p < processo.length; p++) {
            if (processo[p].getTamanho() % quantum != 0) {
                particoes[p] = (processo[p].getTamanho() / quantum) + 1;
            } else {
                particoes[p] = processo[p].getTamanho() / quantum;
            }
        }

        int totalParticoes = 0;

        // calcular o Nro total de particoes
        for (int i : particoes) {
            totalParticoes += i;
        }

        // Criar a 1 lista com as particoes ainda nao ordenada
        ArrayList<String> listaProc = new ArrayList<String>();
        int indice = 0;
        for (int i : particoes) {
            while (i != 0) {
                listaProc.add(processo[indice].getId());
                i--;
            }
            indice++;
        }

        indice = 0;
        ArrayList<String> listaProcOrdenada = new ArrayList<String>();
        /**
         * Criar uma lista com os processos respeitando os momentos de chegada
         */

        // Imprimir as informacoes sobre a execucao do escalonador
        System.out
                .println("ALGORITMO PARA ESCALONADOR ROUND ROBIN - CIRCULAR\n");
        System.out.println("ID: | Chegou em: | Tamanho:");
        for (Processo proc : processo) {
            System.out.println(proc.getId() + "\t" + proc.getMomentoChegada()
                    + "\t\t" + proc.getTamanho());
        }

        System.out.println("\nLINHA DE PROCESSAMENTO: \n");

        // Imprimir a linha de processamento

        /**
         * TO DO - Aqui deveria imprimir os processos de acordo com o momento de chegada,
         * particoes (quantum) e sequencial
         * 
         * EXEMPLO - Processo A=10 Chegou em 5, B=15 Chegou em 3 e C=6 Chegou em 0
         *             Quantum = 2;
         * 
         *  Linha de Processamento: <C> <C> <C> <B> <B> <B> <A> <B> <A> <B> <A> <B> <A> <B> <A> <B>
         * 
         */


        System.out.println("\n\nNº de Processos: " + nroProcessos
                + " | Quantum: " + quantum
                + " | Tempo para troca de Contexto: " + trocaDeContexto);
        System.out.println("Nº de TC: " + totalParticoes
                + " | Tempo gasto com TC: "
                + (totalParticoes * trocaDeContexto));
        double total = somaTamanho + (totalParticoes * trocaDeContexto);
        System.out.println("Tempo - Processamento total: " + total);
        System.out
                .println("Tempo - Percentuais > Processos: "
                        + Math.round((somaTamanho / total) * 100)
                        + "% | T.Contexto: "
                        + Math.round((((totalParticoes * trocaDeContexto) / total) * 100))
                        + "%");

    }
}

Quebrando a cabeça e não estou sabendo como ordenar na medida que os processos chegam. Sei apenas ordenar pelo menor momento, mas depois imprimo como se todos chegassem ao mesmo tempo, apenas intercalando entre eles ( A B C A B C A B C )... Quando na realidade teria que ser algo do tipo ( A A B A B B B C B C B ) isso dependendo dos momentos de chegada dos processos e o consumo de seus quantums (time slices).

  1. Você vai ver essas setas em qualquer página de pergunta. Com elas, você pode dizer se uma pergunta ou uma resposta foram relevantes ou não.
  2. Edite sua pergunta ou resposta caso queira alterar ou adicionar detalhes.
  3. Caso haja alguma dúvida sobre a pergunta, adicione um comentário. O espaço de respostas deve ser utilizado apenas para responder a pergunta.
  4. Se o autor da pergunta marcar uma resposta como solucionada, esta marca aparecerá.
  5. Clique aqui para mais detalhes sobre o funcionamento do GUJ!

0 resposta

Não é a resposta que estava procurando? Procure outras perguntas com as tags algoritmos arraylist java ou faça a sua própria pergunta.