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

Algoritmo de escalonamento de processos por prioridade não preemptivo

Preciso fazer um programa que "simule" um escalonador de processos pelo método de prioridade não preemptivo, estou com dificuldade nas resolução do problema. Segue abaixo a classe responsável..

package source;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Prioridade
{
    private int ent;                  // Entradas

    private List<Integer> pi;          // Pid do Processo
    private List<Integer> pr;          // Prioridade
    private List<Integer> tc;        // Tempo de Ciação Fila APTO
    private List<Integer> te;        // Tempo de Espera Fila APTO
    private List<Integer> tsa;        // Tempo de Saida Fila APTO
    private List<Integer> tb;        // Tempo Entreda na CPU
    private List<Integer> tsc;        // Tempo Saida da CPU

    Random rand = new Random();

    List<Processo> dadosApto;
    List<Processo> dadosCpu;

    List<Integer> exec;

    public Prioridade(int ent)
    {
        this.ent = ent;

        pi = new ArrayList<>();   
        pr = new ArrayList<>(); 
        tc = new ArrayList<>();
        te = new ArrayList<>();
        tsa = new ArrayList<>();
        tb = new ArrayList<>();
        tsc = new ArrayList<>();

        dadosApto = new ArrayList<>();
        dadosCpu = new ArrayList<>();

        exec = new ArrayList<>();

        apto();
    }

    private void pronto()
    {
        for(int i=0; i<ent; i++)
        {
            // Pid do processo
            pi.add(i+1);

            // Prioridade do processo
            pr.add(rand.nextInt(5)+1);

            // Tempo de Criação do processo
            if(i==0)
                tc.add(i);
            else
                tc.add(tc.get(i-1) + (rand.nextInt(10)+1));   // Tempo de criação recebe o tempo acumulado anterior + o tempo relativo de criação
        }
    }

    private void apto()
    {            
        int cont, p;
        boolean flag = false;

        pronto();

        for(int i=0; i<ent; i++)
        {
            // Decisão de qual processo entra na cpu
            if(i != 0)
            {
                cont = 1;
                p = i;
                flag = false;
                while(tc.get(cont) < tsc.get(i-1) || cont < ent)
                {
                    System.out.println(cont +", "+ i +", "+ flag);
                    if(pr.get(i) < pr.get(cont+1))
                        if(!exec.contains(cont))
                        {
                            p = cont;
                            exec.add(p);
                            flag = true;
                        }
                        else
                            if(!flag)
                                p = i;

                    cont++;
                }
            }
            else
                p = i;

            System.out.println(p +", "+ flag);
            cpu(i);

            // Tempo de saida da fila
            if(i == 0)
                tsa.add(tc.get(i));
            else
                if (tsc.get(i-1) < tc.get(p))
                    tsa.add(tc.get(p));
                else
                    tsa.add(tsc.get(i-1));  // Tempo de saida da fila de apto recebe o tempo de saida da cpu do processo anterior.

            // Tempo de espera na fila
            if(i == 0)
                te.add(0);
            else
                if(tsc.get(i-1) < tc.get(p))
                    te.add(0);
                else
                    te.add(tsc.get(i-1)-tc.get(p));   // Tempo de espera é o tempo de saida da fila menos o tempo de criação.

            dadosApto.add(new Processo(pi.get(p), pr.get(p), tc.get(i), te.get(i), tsa.get(i)));
        }
    }

    private void cpu(int i)
    {        
        // Tempo e entrada na CPU
        if(i == 0)
            tb.add(tc.get(i));
        else                
            tb.add(tsc.get(i-1));    // Tempo de entrada recebe o tempo de saida da cpu anterior.

        // Tempo de saida da CPU
        tsc.add(tb.get(i) + (rand.nextInt(20)+1));     // Tempo de saida da cpu rebece o tempo de entrada somado a número randomico que representa o tempo de execuão.

        dadosCpu.add(new Processo(pi.get(i), tb.get(i), tsc.get(i)));
    }

    public List<Processo> getDadosApto()
    {
        return dadosApto;
    }

    public List<Processo> getDadosCpu()
    {
        return dadosCpu;
    }
}
  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!

1 resposta

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