Home > Artigos > Exemplos e Mini-Programas >

Exemplo de Simulador de escalonamento de processos de S.O

Publicado por jmayer13 em 17/09/2012 - 6.800 visualizações

comentários: 15

Exemplo de Simulador de escalonamento de processos de S.O
Escalonamento de processos é uma atividade organizacional feita pelo escalonador da CPU que possibilita executar vários processos de forma mais viável e concorrente.

Este programa simula este escalonamento através de alguns dos principais algoritmos escalonadores (FIFO, SJF-preemptivo, PRIORIDADE-preemptivo e RR).

+Dados de Entrada
-numero de processos
-burst time de cada processo (tempo de execução)
-tempo de chegada de cada processo *prioridade (quando necessário)
+Saída
-tempo de espera de cada processo
-tempo de espera médio de cada algoritmo
-turnaround médio de cada algoritmo
-mostrar qual algoritmo teve o melhor maior desempenho
+Implementar os algoritmos
-FIFO
-STF preemptivo
-PRIORIDADE preemptivo
-RR(quantum definido pelo usuário)

Classe Principal- esta classe cria a interface para o usuário inserir os dados dos processos.
Não foi aplicado um controle do usuário sofisticado para não deixar o programa muito grande.
/*SIMULADOR DE ESCALONAMENTO DE PROCESSOS: S.O. * FIFO, STF preemptivo, PRIORIDADE preemptivo e RR * -- nível de controle de usuário: BAIXO */ package simulador_de_escalonamento; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.*; import javax.swing.table.DefaultTableModel; /** * * @author Jonas */ //Main public class Main {     // quantum     static int qpass;     // resolucao     static int xr, yr;     //janela principal     static JFrame jprincipal;     //tabela em que os processos são inceridos     static JTable table;     //modelo de table     static DefaultTableModel model;     //campo de texto para o quantum     static JTextField tquantum;     //contador de processos     static int p = 0;     //variavel para controle da janela adicionar     static int openJa = 0;     public static void main(String[] args) {         //inicializa frame principal         jprincipal = new JFrame();         jprincipal.setLayout(null);         jprincipal.setTitle("Simulador Escalonamento de processos");         //define resolucao         xr = (int) Resolucao.resolucao(1);         yr = (int) Resolucao.resolucao(2);         jprincipal.setBounds(0, 0, xr, yr);         //define como maximizado         jprincipal.setExtendedState(JFrame.MAXIMIZED_BOTH);         //cria modelo para a tabela         model = new DefaultTableModel() {             @Override             public boolean isCellEditable(int row, int col) {                 return false;             }         };         model.addColumn("Processo");         model.addColumn("Tempo de Chegada");         model.addColumn("Tempo de Execução");         model.addColumn("Prioridade");         //cria tabela         table = new JTable(model);         //cria Scroll         JScrollPane scrollTable = new JScrollPane(table);         scrollTable.setBounds(50, 50, xr - 500, yr - 400);         scrollTable.setHorizontalScrollBar(new JScrollBar(0));         //cria/inicializa demais componentes         JButton badicionar = new JButton("Adicionar Processo");         JButton bremover = new JButton("Remover");         JButton bcalcular = new JButton("Calcular");         JLabel lquantum = new JLabel("Quantum");         tquantum = new JTextField();         //define local         badicionar.setBounds(xr - 400, 100, 150, 30);         bremover.setBounds(xr - 400, 150, 150, 30);         bcalcular.setBounds(xr - 400, 200, 150, 30);         lquantum.setBounds(xr - 400, 300, 60, 20);         tquantum.setBounds(xr - 320, 300, 50, 20);         //adiciona componentes         jprincipal.add(scrollTable);         jprincipal.add(badicionar);         jprincipal.add(bremover);         jprincipal.add(bcalcular);         jprincipal.add(lquantum);         jprincipal.add(tquantum);         //eventos         //evento botao adicionar         badicionar.addActionListener(new ActionListener() {             public void actionPerformed(ActionEvent e) {                 //abre frame                 if (openJa == 0) {                     JAdicionarProcesso ja = new JAdicionarProcesso();                     //define janela como aberta                     openJa = 1;                 }             }         });         // evento botao remover         bremover.addActionListener(new ActionListener() {             public void actionPerformed(ActionEvent e) {                 //remove linha                 int colunas = table.getSelectedColumn();                 int linhas = table.getSelectedRow();                 if (linhas == -1 || colunas == -1) {                     //System.out.println("Selecione linha");                 } else {                     model.removeRow(linhas);                     //decrementa a varialvel de controle para processos                     p--;                 }             }         });         //evento botao calcular         bcalcular.addActionListener(new ActionListener() {             public void actionPerformed(ActionEvent e) {                 //abre frame resultado e pega quantum                 qpass = Integer.parseInt(tquantum.getText());                 Resultado r = new Resultado();             }         });         //conf. finais jprincipal         jprincipal.setVisible(true);         jprincipal.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);     }//fim da main //adiciona linha ao modelo     public static void adicionaLinha(Object nl[]) {         model.addRow(nl);     } }

Classe que calcula o escalonamento, é a implementação dos algoritmos escalonadores.
Depois de pegar os dados da tabela o programa define o tempo total e o número de processos, a partir de um somatório e do número de linhas da tabela respectivamente.
Primeiro é criado um vetor que representa o gráfico de Gantt do respectivo processo e é a partir dele que é definido todo o resto. Depois para determinar os tempos de espera e turnaround de cada processo é feita uma busca da primeira aparição do processo, e é subtraído o tempo atual do tempo de chegada para determinar o tempo de espera. Por fim é determinado o tempo de turnaround que é o tempo de espera mais o tempo de execução.
No caso do RR também é necessário ter um controle do quantum, para que não haja um quantum incompleto oque levaria a um erro.
Para os tempos médios primeiro é somado o tempo de espera de todos os processos, este tempo é dividido pelo número de processos para assim determinar o tempo médio de espera, no caso do tempo médio de turnaround primeiro é somado o tempo total de todos os processos e só dai é dividido pelo número de processos.

/*Calcula FIFO,SJF,PRIORIDADE e RR * cria matrizes a partir da table e faz escalonamentos */ package simulador_de_escalonamento; /** * * @author Jonas */ public class Calcular {     int quantum = 0;     double tempoTotal = 0;     // matrizes     double[][] mD;     double[][] mFIFO;     double[][] mSJF;     double[][] mPrioridade;     double[][] mRR;     //tempo de execução e turnaround de cada algoritmo     static double[] tEspPrio;     static double[] tTurPrio;     static double[] tEspFIFO;     static double[] tTurFIFO;     static double[] tEspSJF;     static double[] tTurSJF;     static double[] tEspRR;     static double[] tTurRR;     // tempo médio     double tmeFIFO = 0;     double tmeSJF = 0;     double tmePrio = 0;     double tmeRR = 0;     int linhas;     public Calcular() {         //determina numero de linhas         linhas = Main.table.getRowCount();         double ttemp;         int clinha = 0;         int i = 0, j = 0;         //determina tempo de execucao somando o tempo de execucao de todos os processos         while (clinha < linhas) {             ttemp = Double.parseDouble((String) Main.table.getValueAt(clinha, 2));             tempoTotal = tempoTotal + ttemp;             clinha++;         }         //inicializa matriz uma para cada algoritmo         mFIFO = new double[linhas][3];         mD = new double[linhas][3];         mSJF = new double[linhas][3];         mPrioridade = new double[linhas][3];         mRR = new double[linhas][3];         //cria matrizes para cada escalonamento e uma geral que não vai ser alterada         while (i < linhas) {             //tempo de chegada             mD[i][0] = Double.parseDouble((String) Main.table.getValueAt(i, 1));             mFIFO[i][0] = Double.parseDouble((String) Main.table.getValueAt(i, 1));             mSJF[i][0] = Double.parseDouble((String) Main.table.getValueAt(i, 1));             mPrioridade[i][0] = Double.parseDouble((String) Main.table.getValueAt(i, 1));             mRR[i][0] = Double.parseDouble((String) Main.table.getValueAt(i, 1));             //tempo de execução             mD[i][1] = Double.parseDouble((String) Main.table.getValueAt(i, 2));             mFIFO[i][1] = Double.parseDouble((String) Main.table.getValueAt(i, 2));             mSJF[i][1] = Double.parseDouble((String) Main.table.getValueAt(i, 2));             mPrioridade[i][1] = Double.parseDouble((String) Main.table.getValueAt(i, 2));             mRR[i][1] = Double.parseDouble((String) Main.table.getValueAt(i, 2));             //prioridade             mD[i][2] = Double.parseDouble((String) Main.table.getValueAt(i, 3));             mFIFO[i][2] = Double.parseDouble((String) Main.table.getValueAt(i, 3));             mSJF[i][2] = Double.parseDouble((String) Main.table.getValueAt(i, 3));             mPrioridade[i][2] = Double.parseDouble((String) Main.table.getValueAt(i, 3));             mRR[i][2] = Double.parseDouble((String) Main.table.getValueAt(i, 3));             i++;         }         //recebe o valor do quantum para o RR         quantum = Main.qpass;     }     //calcula FIFO     public void getFIFO() {         int contFIFO = 0;         int i = 0;         //representacao do gráfico de Gantt         int[] escFIFO = new int[(int) tempoTotal];         //faz FIFO até que o contador alcance o tempo total de execucao         while (contFIFO < tempoTotal) {             //passa processo enquanto o tempo de execução for maior que zero             while (mFIFO[i][1] > 0) {                 //decresse o tempo de execução                 mFIFO[i][1] = mFIFO[i][1] - 1;                 escFIFO[contFIFO] = i;                 contFIFO++;             }             i++;//incrementa o número do processo         }         //calcula tempo de espera e turnaround         contFIFO = 0;         i = 0;         tEspFIFO = new double[(int) linhas];         tTurFIFO = new double[(int) linhas];         int contProcesso = 0;         //procura a primeira "aparição" do processo         while (contProcesso < linhas) {             if (escFIFO[i] == contProcesso) {                 //pega dados da matriz geral já que as outras foram alteradas                 //t. espera = tempo - t.chegada                 tEspFIFO[contProcesso] = i - mD[contProcesso][0];                 //t. turnaround = t. espera + t. execução                 tTurFIFO[contProcesso] = tEspFIFO[contProcesso] + mD[contProcesso][1];                 contProcesso++;             }             if (i + 1 >= tempoTotal) {                 i = 0;             } else {                 i++;             }         }     }     //calcula SJF     public void getSJF() {         int i = 0;         int pmt = 0;         int contSJF = 0;         //representacao do gráfico de Gantt         int[] escSJF = new int[(int) tempoTotal];         //faz SJF até que o contador alcance o tempo total         while (contSJF < tempoTotal) {             //busca menor tempo de execução             int minTime = 9999;             for (i = 0; i < linhas; i++) {                 //se o processo for o menor tempo de execução e já ter chegado                 if (mSJF[i][1] < minTime && mSJF[i][1] > 0 && mSJF[i][0] <= contSJF) {                     minTime = (int) mSJF[i][1];                     pmt = i;                 }             }             //faz SJF             //decressse tempo de execução             mSJF[pmt][1] = mSJF[pmt][1] - 1;             escSJF[contSJF] = pmt;             contSJF++;         }         //calcula tempo de espera e turnround         contSJF = 0;         i = 0;         tEspSJF = new double[(int) linhas];         tTurSJF = new double[(int) linhas];         int contProcesso = 0;         //procura a primeira "aparição" do processo         while (contProcesso < linhas) {             if (escSJF[i] == contProcesso) {                 //pega dados da matriz geral já que as outras foram alteradas                 //t. espera = tempo - t.chegada                 tEspSJF[contProcesso] = i - mD[contProcesso][0];                 //t. turnaround = t. espera + t. execução                 tTurSJF[contProcesso] = tEspSJF[contProcesso] + mD[contProcesso][1];                 contProcesso++;             }             //no caso de não ter encontrado um processo e não ter "terminado o tempo"             //ele zera o i             if (i + 1 >= tempoTotal) {                 i = 0;             } else {                 i++;             }         }     }     //calcula Prioridade     public void getPrioridade() {         int i = 0;         int pmp = 0;         int contPrio = 0;         //representa o gráfico de Gantt         int[] escPrio = new int[(int) tempoTotal];         //faz Priotidade até que o contador alcance o tempo total         while (contPrio < tempoTotal) {             //busca menor prioridade             int minPrio = 9999;             for (i = 0; i < linhas; i++) {                 if (mPrioridade[i][2] < minPrio && mPrioridade[i][1] > 0 && mPrioridade[i][0] <= contPrio) {                     minPrio = (int) mPrioridade[i][2];                     pmp = i;                 }             }             //faz prioridade             //decressse tempo de execução             mPrioridade[pmp][1] = mPrioridade[pmp][1] - 1;             escPrio[contPrio] = pmp;             contPrio++;         }         //calcula tempo de espera e turnround         contPrio = 0;         i = 0;         tEspPrio = new double[(int) linhas];         tTurPrio = new double[(int) linhas];         int contProcesso = 0;         //procura a primeira "aparição" do processo         while (contProcesso < linhas) {             if (escPrio[i] == contProcesso) {                 //pega dados da matriz geral já que as outras foram alteradas                 //t. espera = tempo - t.chegada                 tEspPrio[contProcesso] = i - mD[contProcesso][0];                 tTurPrio[contProcesso] = tEspPrio[contProcesso] + mD[contProcesso][1];                 contProcesso++;             }             //no caso de não ter encontado um processo e não ter "terminado o tempo"             //ele zera o i             if (i + 1 >= tempoTotal) {                 i = 0;             } else {                 i++;             }         }     }     //calcula RR     public void getRR() {         int i = 0;         //contador do quantum         int cQ = 1;         int contRR = 0;         //representa o gráfico de Gantt         int[] escRR = new int[(int) tempoTotal];         //faz o "ciclo" do RR enquanto o tempo não acabar         while (contRR < tempoTotal) {             //faz ciclo ,se o processo tiver acabado ele passo para o próximo             if (mRR[i][1] > 0 && mRR[i][0] <= contRR) {                 //decrementa tempo de execução                 mRR[i][1] = mRR[i][1] - 1;                 escRR[contRR] = i;                 contRR++;                 cQ++;             } else {                 //zera quantum                 cQ = 1;                 //se completou o cilo ele o reinicia se não passa o para o próximo                 if (i + 1 >= linhas) {                     i = 0;                 } else {                     i++;                 }             }             //verifica se o quantum terminou             if (cQ > quantum) {                 cQ = 1;                 //se completou o cilo ele o reinicia se não passa o para o próximo                 if (i + 1 >= linhas) {                     i = 0;                 } else {                     i++;                 }             }             //se completou o cilo ele o reinicia             if (i + 1 > linhas) {                 i = 0;             }         }         //calcula tempo de espera e turnround         contRR = 0;         i = 0;         tEspRR = new double[(int) linhas];         tTurRR = new double[(int) linhas];         int contProcesso = 0;         //procura a primeira "aparição" do processo         while (contProcesso < linhas) {             if (escRR[i] == contProcesso) {                 //pega dados da matriz geral já que as outras foram alteradas                 //t. espera = tempo - t.chegada                 tEspRR[contProcesso] = i - mD[contProcesso][0];                 tTurRR[contProcesso] = tEspRR[contProcesso] + mD[contProcesso][1];                 contProcesso++;             }             //no caso de não ter encontado um processo e não ter "terminado o tempo"             //ele zera o i             if (i + 1 >= tempoTotal) {                 i = 0;             } else {                 i++;             }         }     }     //calcula o melhor algoritmo e retorna     public int getMelhor() {         //retorna 1=fifo 2=sjf 3=prio 4=rr         int c = 0;         if (tmeFIFO < tmeSJF && tmeFIFO < tmePrio && tmeFIFO < tmeRR) {             c = 1;         }         if (tmeSJF < tmeFIFO && tmeSJF < tmePrio && tmeSJF < tmeRR) {             c = 2;         }         if (tmePrio < tmeFIFO && tmePrio < tmeSJF && tmePrio < tmeRR) {             c = 3;         }         if (tmeRR < tmeFIFO && tmeRR < tmeSJF && tmeRR < tmePrio) {             c = 4;         }         return c;     }     //calcula tempo médio de espera de FIFO e o retorna     public double getEsperaFIFO() {         for (int i = 0; i < tEspFIFO.length; i++) {             tmeFIFO = tEspFIFO[i] + tmeFIFO;         }         return tmeFIFO / linhas;     }     //calcula tempo médio de espera de SJF e retorna     public double getEsperaSJF() {         for (int i = 0; i < tEspSJF.length; i++) {             tmeSJF = tEspSJF[i] + tmeSJF;         }         return tmeSJF / linhas;     }     //calcula tempo médio de espera de Prioridade e o retorna     public double getEsperaPrioridade() {         for (int i = 0; i < tEspPrio.length; i++) {             tmePrio = tEspPrio[i] + tmePrio;         }         return tmePrio / linhas;     }     //calcula tempo médio de espera de RR e o retorna     public double getEsperaRR() {         for (int i = 0; i < tEspRR.length; i++) {             tmeRR = tEspRR[i] + tmeRR;         }         return tmeRR / linhas;     }     //calcula turnaround  médio de FIFO e o retorna     public double getTurnaroundFIFO() {         return (tmeFIFO + tempoTotal) / linhas;     }     //calcula turnaround médio de SJF e o retorna     public double getTurnaroundSJF() {         return (tmeSJF + tempoTotal) / linhas;     }     //calcula turnaround médio de Prioridade e o retorna     public double getTurnaroundPrioridade() {         return (tmePrio + tempoTotal) / linhas;     }     //calcula turnaround médio de RR e o retorna     public double getTurnaroundRR() {         return (tmeRR + tempoTotal) / linhas;     } }
Classe que apresenta os resultados, tempos dos processos e circunda o melhor tempo.
/*janela com o resultado  */ package simulador_de_escalonamento; import java.awt.Color; import java.text.NumberFormat; import javax.swing.*; import javax.swing.table.DefaultTableModel; /** * * @author Jonas */ public class Resultado {     JFrame jResultado;     Calcular calc;     int linhas;     public Resultado() {         calc = new Calcular();         //conf frame         jResultado = new JFrame();         jResultado.setLayout(null);         jResultado.setTitle("Resultado");         jResultado.setSize(1000, 725);         jResultado.setLocationRelativeTo(null);         //chama calcula         calc.getFIFO();         calc.getSJF();         calc.getPrioridade();         calc.getRR();         //cria modelos         DefaultTableModel modelFIFO = new DefaultTableModel() {             @Override             public boolean isCellEditable(int row, int col) {                 return false;             }         };         DefaultTableModel modelSJF = new DefaultTableModel() {             @Override             public boolean isCellEditable(int row, int col) {                 return false;             }         };         DefaultTableModel modelPrio = new DefaultTableModel() {             @Override             public boolean isCellEditable(int row, int col) {                 return false;             }         };         DefaultTableModel modelRR = new DefaultTableModel() {             @Override             public boolean isCellEditable(int row, int col) {                 return false;             }         };         //cria coluna models         modelFIFO.addColumn("Processo");         modelFIFO.addColumn("Tempo de Espera");         modelFIFO.addColumn("Tempo de Turnaround");         modelSJF.addColumn("Processo");         modelSJF.addColumn("Tempo de Espera");         modelSJF.addColumn("Tempo de Turnaround");         modelPrio.addColumn("Processo");         modelPrio.addColumn("Tempo de Espera");         modelPrio.addColumn("Tempo de Turnaround");         modelRR.addColumn("Processo");         modelRR.addColumn("Tempo de Espera");         modelRR.addColumn("Tempo de Turnaround");         //popula models         linhas = Main.table.getRowCount();         int contLinha = 0;         while (contLinha < linhas) {             modelFIFO.addRow(new Object[]{"P" + (contLinha + 1), Calcular.tEspFIFO[contLinha], Calcular.tTurFIFO[contLinha]});             modelSJF.addRow(new Object[]{"P" + (contLinha + 1), Calcular.tEspSJF[contLinha], Calcular.tTurSJF[contLinha]});             modelPrio.addRow(new Object[]{"P" + (contLinha + 1), Calcular.tEspPrio[contLinha], Calcular.tTurPrio[contLinha]});             modelRR.addRow(new Object[]{"P" + (contLinha + 1), Calcular.tEspRR[contLinha], Calcular.tTurRR[contLinha]});             contLinha++;         }         //tabela         JTable tableFIFO = new JTable(modelFIFO);         JTable tableSJF = new JTable(modelSJF);         JTable tablePrio = new JTable(modelPrio);         JTable tableRR = new JTable(modelRR);         JScrollPane stableFIFO = new JScrollPane(tableFIFO);         stableFIFO.setHorizontalScrollBar(new JScrollBar(0));         JScrollPane stableSJF = new JScrollPane(tableSJF);         stableSJF.setHorizontalScrollBar(new JScrollBar(0));         JScrollPane stablePrio = new JScrollPane(tablePrio);         stablePrio.setHorizontalScrollBar(new JScrollBar(0));         JScrollPane stableRR = new JScrollPane(tableRR);         stableRR.setHorizontalScrollBar(new JScrollBar(0));         stableFIFO.setBounds(50, 50, 400, 250);         stableSJF.setBounds(550, 50, 400, 250);         stablePrio.setBounds(50, 400, 400, 250);         stableRR.setBounds(550, 400, 400, 250);         //campos de texto tempo de espera e tempo de turnaround         JTextField temFIFO = new JTextField();         JTextField ttmFIFO = new JTextField();         JTextField temSJF = new JTextField();         JTextField ttmSJF = new JTextField();         JTextField temPrio = new JTextField();         JTextField ttmPrio = new JTextField();         JTextField temRR = new JTextField();         JTextField ttmRR = new JTextField();         temFIFO.setEditable(false);         ttmFIFO.setEditable(false);         temSJF.setEditable(false);         ttmSJF.setEditable(false);         temPrio.setEditable(false);         ttmPrio.setEditable(false);         temRR.setEditable(false);         ttmRR.setEditable(false);         temFIFO.setBounds(150, 315, 100, 20);         ttmFIFO.setBounds(370, 315, 100, 20);         temSJF.setBounds(650, 315, 100, 20);         ttmSJF.setBounds(870, 315, 100, 20);         temPrio.setBounds(150, 665, 100, 20);         ttmPrio.setBounds(370, 665, 100, 20);         temRR.setBounds(650, 665, 100, 20);         ttmRR.setBounds(870, 665, 100, 20);         //formata tempos e passa para tfs         temFIFO.setText("" + NumberFormat.getNumberInstance().format(calc.getEsperaFIFO()));         ttmFIFO.setText("" + NumberFormat.getNumberInstance().format(calc.getTurnaroundFIFO()));         temSJF.setText("" + NumberFormat.getNumberInstance().format(calc.getEsperaSJF()));         ttmSJF.setText("" + NumberFormat.getNumberInstance().format(calc.getTurnaroundSJF()));         temPrio.setText("" + NumberFormat.getNumberInstance().format(calc.getEsperaPrioridade()));         ttmPrio.setText("" + NumberFormat.getNumberInstance().format(calc.getTurnaroundPrioridade()));         temRR.setText("" + NumberFormat.getNumberInstance().format(calc.getEsperaRR()));         ttmRR.setText("" + NumberFormat.getNumberInstance().format(calc.getTurnaroundRR()));         //labels         JLabel ltemFIFO = new JLabel("T.Espera Médio");         JLabel lttmFIFO = new JLabel("T.Turnaround Médio");         JLabel ltemSJF = new JLabel("T.Espera Médio");         JLabel lttmSJF = new JLabel("T.Turnaround Médio");         JLabel ltemPrio = new JLabel("T.Espera Médio");         JLabel lttmPrio = new JLabel("T.Turnaround Médio");         JLabel ltemRR = new JLabel("T.Espera Médio");         JLabel lttmRR = new JLabel("T.Turnaround Médio");         JLabel lFIFO = new JLabel("FIFO");         JLabel lSJF = new JLabel("SJF");         JLabel lPrio = new JLabel("Prioridade");         JLabel lRR = new JLabel("RR");         ltemFIFO.setBounds(50, 315, 100, 20);         lttmFIFO.setBounds(250, 315, 120, 20);         ltemSJF.setBounds(550, 315, 100, 20);         lttmSJF.setBounds(750, 315, 120, 20);         ltemPrio.setBounds(50, 665, 100, 20);         lttmPrio.setBounds(250, 665, 120, 20);         ltemRR.setBounds(550, 665, 100, 20);         lttmRR.setBounds(750, 665, 120, 20);         lFIFO.setBounds(50, 30, 100, 20);         lSJF.setBounds(550, 30, 100, 20);         lPrio.setBounds(50, 380, 100, 20);         lRR.setBounds(550, 380, 100, 20);         //l bordas para o melhor         int posicao = calc.getMelhor();         if (posicao == 1) {             stableFIFO.setBorder(BorderFactory.createLineBorder(Color.RED));         }         if (posicao == 2) {             stableSJF.setBorder(BorderFactory.createLineBorder(Color.RED));         }         if (posicao == 3) {             stablePrio.setBorder(BorderFactory.createLineBorder(Color.RED));         }         if (posicao == 4) {             stableRR.setBorder(BorderFactory.createLineBorder(Color.RED));         }         //adiciona ao frame         jResultado.add(stableFIFO);         jResultado.add(stableSJF);         jResultado.add(stablePrio);         jResultado.add(stableRR);         jResultado.add(temFIFO);         jResultado.add(ttmFIFO);         jResultado.add(temSJF);         jResultado.add(ttmSJF);         jResultado.add(temPrio);         jResultado.add(ttmPrio);         jResultado.add(temRR);         jResultado.add(ttmRR);         jResultado.add(ltemFIFO);         jResultado.add(lttmFIFO);         jResultado.add(ltemSJF);         jResultado.add(lttmSJF);         jResultado.add(ltemPrio);         jResultado.add(lttmPrio);         jResultado.add(ltemRR);         jResultado.add(lttmRR);         jResultado.add(lFIFO);         jResultado.add(lSJF);         jResultado.add(lPrio);         jResultado.add(lRR);         //fin frame         jResultado.setVisible(true);         jResultado.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);     } }

----------------------

Tópicos Relacionados


• Ajustando as informações de horário de verão no Java  
• Problemas  
• Netbeans, problema quando executa.  
• GOS - grid operating sytem  
• Preciso de ajuda para Escalonador  
• Programação Concorrente  
• Windows 8: como o logotipo do Windows mudou  
• Simulador de Processador  
• Ubuntu Mobile OS  
• Ajudem por favor: Escalonamento...  

Home Sobre Anuncie

O JavaFree.org é uma comunidade java formada pela coolaboração dos desenvolvedores da tecnologia java. A publicação de artigos além de ajudar a comunidade java, ajuda a dar maior visibilidade para o autor. Contribua conosco.