Exemplo de Simulador de escalonamento de processos de S.O
[color=red]Exemplo de Simulador de escalonamento de processos de S.O[/color]
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.
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.
Classe que apresenta os resultados, tempos dos processos e circunda o melhor tempo.
----------------------
/*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);
}
}
/*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;
}
}
/*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);
}
}
Jonas Mayer
Curtidas 0
Melhor post
Jonas Mayer
24/08/2012
[quote="jmayer13"]Ops... não adicionei essa classe no artigo.
Classe responsável por adicionar processos a tabela:
Muito Obrigado.
/*Janela para adicionar a tabela
*/
package simulador_de_escalonamento;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
/**
*
* @author Jonas
*/
public class JAdicionarProcesso {
static JFrame jAdicionar;
static Object[] nl;
JTextField tprocesso;
JTextField ttc;
JTextField tte;
JTextField tprioridade;
//cria janela
public JAdicionarProcesso() {
Main.p++;
//inicializa janela
jAdicionar = new JFrame();
//define propriedades
jAdicionar.setTitle("Adicionar Processo");
jAdicionar.setLayout(null);
jAdicionar.setSize(400, 300);
jAdicionar.setLocationRelativeTo(null);
//cria componentes
JLabel lprocesso = new JLabel("Processo");
JLabel ltc = new JLabel("Tempo de Chegada");
JLabel lte = new JLabel("Tempo de Execução");
JLabel lprioridade = new JLabel("Prioridade");
tprocesso = new JTextField();
ttc = new JTextField();
tte = new JTextField();
tprioridade = new JTextField();
JButton bok = new JButton("OK");
JButton bcancel = new JButton("CANCELAR");
//define propriedade dos componentes
lprocesso.setBounds(30, 30, 100, 20);
ltc.setBounds(30, 70, 150, 20);
lte.setBounds(30, 110, 150, 20);
lprioridade.setBounds(30, 150, 100, 20);
tprocesso.setBounds(170, 30, 80, 20);
ttc.setBounds(170, 70, 80, 20);
tte.setBounds(170, 110, 80, 20);
tprioridade.setBounds(170, 150, 80, 20);
bok.setBounds(160, 220, 100, 30);
bcancel.setBounds(280, 220, 100, 30);
//define processo ("P"+var)
tprocesso.setEditable(false);
tprocesso.setText("P" + Main.p);
//adiciona a janela
jAdicionar.add(lprocesso);
jAdicionar.add(ltc);
jAdicionar.add(lte);
jAdicionar.add(lprioridade);
jAdicionar.add(tprocesso);
jAdicionar.add(ttc);
jAdicionar.add(tte);
jAdicionar.add(tprioridade);
jAdicionar.add(bok);
jAdicionar.add(bcancel);
//eventos
bok.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
//adiciona lina
nl = new Object[]{tprocesso.getText(),ttc.getText() ,tte.getText() ,tprioridade.getText() };
Main.adicionaLinha(nl);
Main.openJa=0;
jAdicionar.dispose();
}
});
bcancel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Main.p--;
Main.openJa=0;
jAdicionar.dispose();
}
});
//opcoes finais da janela
jAdicionar.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
jAdicionar.setVisible(true);
}
public static void main(String args[]) {
JAdicionarProcesso ja = new JAdicionarProcesso();
}
}GOSTEI 1
Mais Respostas
Jonas Mayer
15/06/2012
Onde posso encontrar a classe [b]JAdicionarProcesso[/b]?
GOSTEI 0
Jonas Mayer
15/06/2012
Ops... não adicionei essa classe no artigo.
Classe responsável por adicionar processos a tabela:
/*Janela para adicionar a tabela
*/
package simulador_de_escalonamento;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;
/**
*
* @author Jonas
*/
public class JAdicionarProcesso {
static JFrame jAdicionar;
static Object[] nl;
JTextField tprocesso;
JTextField ttc;
JTextField tte;
JTextField tprioridade;
//cria janela
public JAdicionarProcesso() {
Main.p++;
//inicializa janela
jAdicionar = new JFrame();
//define propriedades
jAdicionar.setTitle("Adicionar Processo");
jAdicionar.setLayout(null);
jAdicionar.setSize(400, 300);
jAdicionar.setLocationRelativeTo(null);
//cria componentes
JLabel lprocesso = new JLabel("Processo");
JLabel ltc = new JLabel("Tempo de Chegada");
JLabel lte = new JLabel("Tempo de Execução");
JLabel lprioridade = new JLabel("Prioridade");
tprocesso = new JTextField();
ttc = new JTextField();
tte = new JTextField();
tprioridade = new JTextField();
JButton bok = new JButton("OK");
JButton bcancel = new JButton("CANCELAR");
//define propriedade dos componentes
lprocesso.setBounds(30, 30, 100, 20);
ltc.setBounds(30, 70, 150, 20);
lte.setBounds(30, 110, 150, 20);
lprioridade.setBounds(30, 150, 100, 20);
tprocesso.setBounds(170, 30, 80, 20);
ttc.setBounds(170, 70, 80, 20);
tte.setBounds(170, 110, 80, 20);
tprioridade.setBounds(170, 150, 80, 20);
bok.setBounds(160, 220, 100, 30);
bcancel.setBounds(280, 220, 100, 30);
//define processo ("P"+var)
tprocesso.setEditable(false);
tprocesso.setText("P" + Main.p);
//adiciona a janela
jAdicionar.add(lprocesso);
jAdicionar.add(ltc);
jAdicionar.add(lte);
jAdicionar.add(lprioridade);
jAdicionar.add(tprocesso);
jAdicionar.add(ttc);
jAdicionar.add(tte);
jAdicionar.add(tprioridade);
jAdicionar.add(bok);
jAdicionar.add(bcancel);
//eventos
bok.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
//adiciona lina
nl = new Object[]{tprocesso.getText(),ttc.getText() ,tte.getText() ,tprioridade.getText() };
Main.adicionaLinha(nl);
Main.openJa=0;
jAdicionar.dispose();
}
});
bcancel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
Main.p--;
Main.openJa=0;
jAdicionar.dispose();
}
});
//opcoes finais da janela
jAdicionar.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
jAdicionar.setVisible(true);
}
public static void main(String args[]) {
JAdicionarProcesso ja = new JAdicionarProcesso();
}
}GOSTEI 0
Davi Costa
15/06/2012
E a classe Resolucao?
abcs
GOSTEI 0
Davi Costa
15/06/2012
[quote="davi.costa"]E a classe Resolucao?
abcs
Não seria Resultado?
Se sim, ela se encontra no tutorial.
GOSTEI 0
Davi Costa
15/06/2012
Dá uma olhada no artigo que a classe Main chama essa classe Resolucao.
abcs
GOSTEI 0
Davi Costa
15/06/2012
[quote="davi.costa"]Dá uma olhada no artigo que a classe Main chama essa classe Resolucao.
abcs
Entendi, como aqui quando fui verificar só estava faltando a classe JAdicionarProcesso, imagino que essa seja uma classe ligada ao swing.
Vou testar mais tarde e posto o resultado.
GOSTEI 0
Davi Costa
15/06/2012
Com o nome Resolucao e sem import's acho que não, deve ser implementação do autor do artigo mesmo.
abcs
GOSTEI 0
Davi Costa
15/06/2012
[quote="davi.costa"]Com o nome Resolucao e sem import's acho que não, deve ser implementação do autor do artigo mesmo.
abcs
Tem o Java.Swing.*, sei que é uma suposição estranha, mas pelo menos quando joguei as classes no Netbeans, essa JAdicionarProcesso, foi a única linha a apresentar erro.
Mas como eu disse, novamente vou fazer testes hoje a tarde.
GOSTEI 0
Davi Costa
15/06/2012
[quote="davi.costa"]Com o nome Resolucao e sem import's acho que não, deve ser implementação do autor do artigo mesmo.
abcs
Você tem razão, no entanto consegui fazer o programa funcionar e realizar testes colocando um inteiro pra setar as varáveis da resolução, no meu caso, 800 x 600.
GOSTEI 0
Jonas Mayer
15/06/2012
Essa classe é bem simples serve apenas para pegar a resolução do usuário para gerar o frame com essa resolução.
package simulador_de_escalonamento;
import java.awt.Dimension;
import java.awt.Toolkit;
public class Resolucao {
public static double resolucao(int tipo) {
//1=x; 2=y
Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
double x = dim.getWidth();//largura
double y = dim.getHeight();//altura
if (tipo == 1) {
return x;
} else {
return y;
}
}GOSTEI 0
Davi Costa
15/06/2012
Valeu jmayer. Obrigado.
abcs
GOSTEI 0
Felipe Dias
15/06/2012
Adiciono um novo processo coloco o Quantum mas quando mando ele calcular ele trava a execução e não me permite fazer mais nada... É só aqui isso?
GOSTEI 0
Jonas Mayer
15/06/2012
[quote="felipejdias"]Adiciono um novo processo coloco o Quantum mas quando mando ele calcular ele trava a execução e não me permite fazer mais nada... É só aqui isso?
Você esta cumprindo com as regras do escalonamento?
-pelo menos um processo inicia no tempo 0
-não ha espaços de tempo entre os processos e
- tanto tempo, prioridade e quantiun são inteiros
GOSTEI 0
Felipe Dias
15/06/2012
[quote="jmayer13"]Você esta cumprindo com as regras do escalonamento?
-pelo menos um processo inicia no tempo 0
-não ha espaços de tempo entre os processos e
- tanto tempo, prioridade e quantiun são inteiros
Obrigado, realmente não estava sabendo como usar o seu simulador... Obrigado por postar esse simulador pra gente vai ser muito útil pra mim. :evil:
GOSTEI 0
Karina Paes
15/06/2012
Olá (=
Tenho uma dúvida (desculpa ressuscitar o tópico rs)..
O seu programa calcula o tempo de espera somente sequencialmente né?! Por exemplo, tenho 3 processos de mesma prioridade, o 1º começa no tempo 0, o 2º no tempo 1 e o 3º no tempo 0.. Reparei que no resultado o tempo de espera do 3º processo é maior do que o tempo de espera do 2º processo, ao invés de ser ao contrário, pois o 3º processo inicia a sua execução no 0, então ele teria que esperar o fim da execução do 1º para poder ser executado e não esperar o término da execução do 2º processo..
Alguma sugestão de como alterar a ordem de execução? Enquanto isso, vou pensar numa e realizar alguns testes xD
Obrigada desde já.
GOSTEI 0