Evento Docente Universida del Mar
Mostrando entradas con la etiqueta SW Sistemas Operativos JAVA. Mostrar todas las entradas
Mostrando entradas con la etiqueta SW Sistemas Operativos JAVA. Mostrar todas las entradas

Clase VentanaEliminaModificaProcesos

import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;

public class VentanaEliminaModificaProcesos extends JFrame implements ActionListener {
Vector VectorProcesos;

private String StringNombre;

private int IntTiempoLlegada;

private int IntTiempoRafaga;

private int IntPrioridad;

private GridLayout GridControles;

private JPanel PanelProcesos;

private JLabel JLabelNombre, JLabelLlegada, JLabelRafaga, JLabelPrioridad;

private JTextField JTextLlegada, JTextRafaga, JTextPrioridad;
private JComboBox JComboNombre;
private int i=0,j=0;
private JMenu JMenuProcesos;

private JMenuItem JMeEliminar, JMenuModificar,JMenuGuardar, JMenuSalir;

public VentanaEliminaModificaProcesos(Vector VectorProcesos){
setTitle("ELIMINAR / EDITAR");
setSize(500, 600);
this.VectorProcesos = VectorProcesos;

JMenuProcesos = new JMenu("Proceso");

JMeEliminar = new JMenuItem("Eliminar", new ImageIcon("eVentana.png"));
JMeEliminar.addActionListener(this);
JMenuProcesos.add(JMeEliminar);
JMenuProcesos.addSeparator();

JMenuModificar=new JMenuItem("Modificar",new ImageIcon("modifica.png"));
JMenuModificar.addActionListener(this);
JMenuProcesos.add(JMenuModificar);
JMenuProcesos.addSeparator();

JMenuGuardar = new JMenuItem("Guardar", new ImageIcon("gVentana.png"));
JMenuGuardar.addActionListener(this);
JMenuGuardar.setEnabled(false);
JMenuProcesos.add(JMenuGuardar);
JMenuProcesos.addSeparator();

JMenuSalir = new JMenuItem("Salir", new ImageIcon("sVentana.png"));
JMenuSalir.addActionListener(this);
JMenuProcesos.add(JMenuSalir);

GridControles = new GridLayout(4, 2, 10, 10);
PanelProcesos = new JPanel();
PanelProcesos.setLayout(GridControles);

PanelProcesos.add(JLabelNombre = new JLabel(" Nombre del Proceso"));
PanelProcesos.add(JComboNombre = new JComboBox());
JComboNombre.addActionListener(this);

PanelProcesos.add(JLabelLlegada = new JLabel(" Tiempo de Llegada"));
PanelProcesos.add(JTextLlegada = new JTextField(10));
JTextLlegada.setHorizontalAlignment(JTextField.CENTER);
JTextLlegada.addActionListener(this);
JTextLlegada.setEditable(false);

PanelProcesos.add(JLabelRafaga = new JLabel(" Tiempo de Rafaga"));
PanelProcesos.add(JTextRafaga = new JTextField(10));
JTextRafaga.setHorizontalAlignment(JTextField.CENTER);
JTextRafaga.addActionListener(this);
JTextRafaga.setEditable(false);

PanelProcesos.add(JLabelPrioridad = new JLabel(" Prioridad"));
PanelProcesos.add(JTextPrioridad = new JTextField(10));
JTextPrioridad.setHorizontalAlignment(JTextField.CENTER);
JTextPrioridad.addActionListener(this);
JTextPrioridad.setEditable(false);

JMenuBar barra = new JMenuBar();
setJMenuBar(barra);
barra.add(JMenuProcesos);

getContentPane().add(PanelProcesos);
setSize(300, 250);
setResizable(false);

if (!VectorProcesos.isEmpty()){
setVisible(true);
LlenaCombo();
}
else{
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. Debe almacenar almenos un proceso","No hay procesos",JOptionPane.WARNING_MESSAGE);
}
}
public void LlenaCombo(){
i=0;
for (i=0;i JComboNombre.addItem(((Procesos)VectorProcesos.elementAt(i)).getStringNombre());
}
}
public void habilitaCampos(boolean estado){
JTextLlegada.setEditable(estado);
JTextRafaga.setEditable(estado);
JTextPrioridad.setEditable(estado);
}
public void actionPerformed(ActionEvent arg0) {
if (arg0.getSource().equals(JComboNombre)) {
j=0;
for (j=0;j if (((Procesos)VectorProcesos.elementAt(j)).getStringNombre()==JComboNombre.getSelectedItem().toString()){
JTextLlegada.setText(String.valueOf(((Procesos)VectorProcesos.elementAt(j)).getIntTiempoLlegada()));
JTextRafaga.setText(String.valueOf(((Procesos)VectorProcesos.elementAt(j)).getIntTiempoRafaga()));
JTextPrioridad.setText(String.valueOf(((Procesos)VectorProcesos.elementAt(j)).getIntPrioridad()));
}
}
}/*FIN EVENTO DEL COMBO*/
if (arg0.getSource().equals(JMeEliminar)) {
int EliminarProcesoOk=JOptionPane.showConfirmDialog(null,"¿Deseas eliminar este Proceso?","Eliminar Procesos",JOptionPane.YES_NO_OPTION,JOptionPane.WARNING_MESSAGE);
if (EliminarProcesoOk==JOptionPane.YES_OPTION){/*Si se hizo clic en el boton SI*/
VectorProcesos.remove(JComboNombre.getSelectedIndex());
JComboNombre.removeActionListener(this);
JComboNombre.removeAllItems();
LlenaCombo();
JComboNombre.addActionListener(this);
}
}/*FIN DEL EVENTO ELIMINAR PROCESO*/
if (arg0.getSource().equals(JMenuModificar)) {
habilitaCampos(true);
JMenuModificar.setEnabled(false);
JMenuGuardar.setEnabled(true);
JMeEliminar.setEnabled(false);
}/*FIN EVENTO MODIFICAR*/
if (arg0.getSource().equals(JMenuGuardar)) {
JMenuModificar.setEnabled(true);
JMeEliminar.setEnabled(true);
JMenuGuardar.setEnabled(false);
habilitaCampos(false);

StringNombre = JComboNombre.getSelectedItem().toString();
IntTiempoLlegada = Integer.parseInt(JTextLlegada.getText());
IntTiempoRafaga = Integer.parseInt(JTextRafaga.getText());
IntPrioridad = Integer.parseInt(JTextPrioridad.getText());

for (j=0;j if (((Procesos)VectorProcesos.elementAt(j)).getStringNombre()==StringNombre){
((Procesos)VectorProcesos.elementAt(j)).setStringNombre(StringNombre);
((Procesos)VectorProcesos.elementAt(j)).setIntTiempoLlegada(IntTiempoLlegada);
((Procesos)VectorProcesos.elementAt(j)).setIntTiempoRafaga(IntTiempoRafaga);
((Procesos)VectorProcesos.elementAt(j)).setIntPrioridad(IntPrioridad);
}
}

}/*FIN EVENTO GUARDAR*/
if (arg0.getSource().equals(JMenuSalir)) {
setVisible(false);
}/*FIN EVENTO SALIR*/
if (arg0.getSource().equals(JTextLlegada)) {
JTextRafaga.grabFocus();
}
if (arg0.getSource().equals(JTextRafaga)) {
JTextPrioridad.grabFocus();
}
if (arg0.getSource().equals(JTextPrioridad)) {
JTextLlegada.grabFocus();
}
}/*FIN DEL ACTION PERFORMED*/

}

Tags:

Clase VentanaAgregaProcesos

import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;

public class VentanaAgregaProcesos extends JFrame implements ActionListener {
Vector VectorProcesos;

int IntTiempoLlegada=0;
private String StringNombre;

private int IntTiempoRafaga;

private int IntPrioridad;

private GridLayout GridControles;

private JPanel PanelProcesos;

private JLabel JLabelNombre, JLabelLlegada, JLabelRafaga, JLabelPrioridad;

private JTextField JTextNombre, JTextLlegada, JTextRafaga, JTextPrioridad;

private JMenu JMenuProcesos;

private JMenuItem JMenuNuevo, JMenuGuardar, JMenuSalir;

public VentanaAgregaProcesos(Vector VectorProcesos) {
setTitle("AGREGAR PROCESOS");
setSize(500, 600);
this.VectorProcesos = VectorProcesos;

JMenuProcesos = new JMenu("Proceso");
JMenuProcesos.setMnemonic('P');

JMenuNuevo = new JMenuItem("Nuevo", new ImageIcon("mnuevo.png"));
JMenuNuevo.setMnemonic('N');
JMenuNuevo.addActionListener(this);
JMenuProcesos.add(JMenuNuevo);
JMenuProcesos.addSeparator();

JMenuGuardar = new JMenuItem("Guardar", new ImageIcon("gVentana.png"));
JMenuGuardar.setMnemonic('G');
JMenuGuardar.setEnabled(false);
JMenuGuardar.addActionListener(this);
JMenuProcesos.add(JMenuGuardar);
JMenuProcesos.addSeparator();

JMenuSalir = new JMenuItem("Salir", new ImageIcon("sVentana.png"));
JMenuSalir.setMnemonic('S');
JMenuSalir.addActionListener(this);
JMenuProcesos.add(JMenuSalir);

GridControles = new GridLayout(4, 2, 10, 10);
PanelProcesos = new JPanel();
PanelProcesos.setLayout(GridControles);

PanelProcesos.add(JLabelNombre = new JLabel(" Nombre del Proceso"));
PanelProcesos.add(JTextNombre = new JTextField(10));
JTextNombre.setHorizontalAlignment(JTextField.CENTER);
JTextNombre.addActionListener(this);
JTextNombre.setEditable(false);

PanelProcesos.add(JLabelLlegada = new JLabel(" Tiempo de Llegada"));
PanelProcesos.add(JTextLlegada = new JTextField(10));
JTextLlegada.setHorizontalAlignment(JTextField.CENTER);
JTextLlegada.addActionListener(this);
JTextLlegada.setEditable(false);

PanelProcesos.add(JLabelRafaga = new JLabel(" Tiempo de Rafaga"));
PanelProcesos.add(JTextRafaga = new JTextField(10));
JTextRafaga.setHorizontalAlignment(JTextField.CENTER);
JTextRafaga.addActionListener(this);
JTextRafaga.setEditable(false);

PanelProcesos.add(JLabelPrioridad = new JLabel(" Prioridad"));
PanelProcesos.add(JTextPrioridad = new JTextField(10));
JTextPrioridad.setHorizontalAlignment(JTextField.CENTER);
JTextPrioridad.addActionListener(this);
JTextPrioridad.setEditable(false);

JMenuBar barra = new JMenuBar();
setJMenuBar(barra);
barra.add(JMenuProcesos);

getContentPane().add(PanelProcesos);
setSize(300, 250);
setVisible(true);
setResizable(false);

}/* FIN DEL CONSTRUCTOR */
public void habilitaCampos(boolean estado){
//JTextNombre.setEditable(estado);
//JTextLlegada.setEditable(estado);
JTextRafaga.setEditable(estado);
JTextPrioridad.setEditable(estado);
}
public void actionPerformed(ActionEvent arg0) {
if (arg0.getSource().equals(JMenuNuevo)) {
JMenuGuardar.setEnabled(true);
JMenuSalir.setEnabled(false);
JMenuNuevo.setEnabled(false);

JTextNombre.setText("P"+String.valueOf(VectorProcesos.size()+1));
JTextLlegada.setText(String.valueOf(VectorProcesos.size()));
JTextRafaga.setText("");
JTextRafaga.grabFocus();
JTextPrioridad.setText("");
habilitaCampos(true);


}/* FIN EVENTO NUEVO */
if (arg0.getSource().equals(JMenuGuardar)) {
JMenuGuardar.setEnabled(false);
JMenuSalir.setEnabled(true);
JMenuNuevo.setEnabled(true);

StringNombre = JTextNombre.getText();
IntTiempoLlegada = Integer.parseInt(JTextLlegada.getText());
IntTiempoRafaga = Integer.parseInt(JTextRafaga.getText());
IntPrioridad = Integer.parseInt(JTextPrioridad.getText());
habilitaCampos(false);

Procesos agrega = new Procesos(StringNombre, IntTiempoLlegada,
IntTiempoRafaga, IntPrioridad);
VectorProcesos.addElement(agrega);
}/* FIN EVENTO GUARDAR */
if (arg0.getSource().equals(JMenuSalir)) {
setVisible(false);
}/* FIN EVENTO SALIR */
if (arg0.getSource().equals(JTextNombre)) {
JTextLlegada.grabFocus();
}
if (arg0.getSource().equals(JTextLlegada)) {
JTextRafaga.grabFocus();
}
if (arg0.getSource().equals(JTextRafaga)) {
JTextPrioridad.grabFocus();
}
if (arg0.getSource().equals(JTextPrioridad)) {
JTextRafaga.grabFocus();
}
}/* FIN DEL ACTION PERFORMED EVENT */

}/* FIN DE LA CLASE VENTANA */

Tags:

Clase del algoritmo SJFCooperativo

import java.util.Arrays;
import java.util.Vector;

public class SJFCooperativo {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE EVALUA EL TIEMPO DE RAFAGA
QUE SE LE ASIGNARON A LOS PROCESOS, Y EJECUTA EL PROCESO QUE TIENE EL TIEMPO DE RAFAGA MENOR*/
Vector VectorProcesos;
private int DoubleTiempoEspera;
private double DoubleTiempoEspera1;
private int NumeroProceso[];
Arrays vector;
private int vectoraux[];
private String ProcesosNombres[];
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public SJFCooperativo(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
vectoraux=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public void getTiempoEsperaPromedio(){
int i=0;
for (i=0;i vectoraux[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
}
ordena(); /*ordenando los procesos*/
for (i=0;i System.out.println(ProcesosNombres[i]+">>"+vectoraux[i]);
}

DoubleTiempoEspera=vectoraux[0];
for (i=1;i DoubleTiempoEspera+=vectoraux[i];
vectoraux[i]=DoubleTiempoEspera;
}

DoubleTiempoEspera1=0;
for (i=0;i DoubleTiempoEspera1+=vectoraux[i];
}

DoubleTiempoEspera1=DoubleTiempoEspera1/VectorProcesos.size();
}
public void ordena(){
int aux,aux2,k,i;
String aux1;

for(i=1;i aux = vectoraux[i];
aux1= ProcesosNombres[i];
aux2=NumeroProceso[i];
k=i-1;
while (k >= 0 && aux < vectoraux[k]){
vectoraux[k+1] = vectoraux[k];
ProcesosNombres[k+1]=ProcesosNombres[k];
NumeroProceso[k+1]=NumeroProceso[k];
k=k-1;
}
vectoraux[k+1] = aux;
ProcesosNombres[k+1]=aux1;
NumeroProceso[k+1]=aux2;
}
}
/*DEVUELVE UN VECTOR CON EL NUEVO TIEMPO DE RAFAGA*/
public int[] getValores(){
return vectoraux;
}
/*SE DEVUELVE LOS NOMBRES DE LOS PROCESOS*/
public String []getNombre(){
return ProcesosNombres;
}
/*SE DEVUELVE EL NUMERO DEL PROCESO*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*DEVUELVE EL TIEMPO PROMEDIO DE ESPERA*/
public double imprimeResultado(){
return DoubleTiempoEspera1;
}
}

Tags:

Clase del algoritmo SJFApropiativo

import java.util.Vector;

public class SJFApropiativo {
Vector VectorProcesos;
Vector ProcesosParaDiagrama=new Vector();
private double DoubleTiempoEspera=0;
private int DoubleTiempoEspera1=0;
private int VectorTiempoRafaga[];
private int NumeroProceso[];
private String ProcesosNombres[];
private double VectorTiempoLlegada[];

public SJFApropiativo(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
VectorTiempoRafaga=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
VectorTiempoLlegada=new double[VectorProcesos.size()];
}
public void getTiempoEsperaPromedio(){
for (int i=0;i ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
VectorTiempoRafaga[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
VectorTiempoLlegada[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada();
}

for(int i=0;i for(int j=0;j if(VectorTiempoLlegada[j]==j){
VectorTiempoRafaga[j]-=j;
ProcesosParaDiagrama.add(j,new Integer(NumeroProceso[j]));
}
}
}
for(int i=0;i System.out.println(ProcesosParaDiagrama.elementAt(i).toString());
}

}
}

Tags:

Clase SimuladorPORTURNOS

/*ESTA CLASE AYUDA A HACER LA SIMULACION DEL ALGORITMO POR TURNOS*/
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class SimuladorPORTURNOS extends JFrame implements ActionListener{
private JButton Cuadricula[][]=new JButton[30][25];
private JPanel PanelContenedor=new JPanel();
private int NumProceso=0;
private int NumProceso1=0;
private int orden=0,orden1=0;;

public SimuladorPORTURNOS(){/*CONSTRUCTOR*/
PanelContenedor.setLayout(new GridLayout(30,25,0,0));
NumProceso1=NumProceso;
/*CREANDO LA CUADRICULA DE BOTONES QUE SIMULAN LOS PROCESOS*/
for(int i=0;i<30;i++){
for (int j=0;j<25;j++){
Cuadricula[i][j]=new JButton("");
Cuadricula[i][j].setVisible(false);
PanelContenedor.add(Cuadricula[i][j]);
/*ESTABLECIENDO EN POSICIONES FIJAS LOS ESTADOS*/
if (i==8 && j==8){
Cuadricula[i][j].setText("L");
Cuadricula[i][j].setToolTipText("Estado LISTO");
Cuadricula[i][j].setVisible(true);
}
if (i==8 && j==17){
Cuadricula[i][j].setText("E");
Cuadricula[i][j].setToolTipText("Estado EJECUCION");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==0){
Cuadricula[i][j].setText("N");
Cuadricula[i][j].setToolTipText("Estado NUEVO");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==24){
Cuadricula[i][j].setText("T");
Cuadricula[i][j].setToolTipText("Estado TERMINADO");
Cuadricula[i][j].setVisible(true);
}
}/*Termina FOR*/
}/*Termina FOR*/

getContentPane().add(PanelContenedor);
setSize(1000,800);
setResizable(true);
setVisible(true);
}/*FIN CONSTRUCTOR*/
/*MOVIENDO EL ESTADO ACTUAL DESDE EL ESTADO LSITO HASTA EL ESTADO EJECUCION
* limite EQUIVALE AL NUMERO DEL PROCESO*/
public void Listo_Ejecucion(int limite){
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=8;i<=17;i++){
Cuadricula[7][i].setText(String.valueOf(limite));
Cuadricula[7][i].setBackground(fondo);
Cuadricula[7][i].setVisible(true);
Cuadricula[7][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
}/*FIN Listo_Ejecucion*/
/*MOVIENDO EL PROCESO ACTUAL DESDE EL ESTADO DE EJECUCION HASTA EL ESTADO DE
* LISTO, ESTO, CUANDO SE ES DESALJADO POR OTRO PORCESO. limite ES IGUAL AL NUMERO
* DEL PROCESO*/
public void Ejecucion_Listo(int limite){
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=17;i>=8;i--){
Cuadricula[9][i].setText(String.valueOf(limite));
Cuadricula[9][i].setBackground(fondo);
Cuadricula[9][i].setVisible(true);
Cuadricula[9][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
}/*FIN Ejecucion_Listo*/
/*MOVIENDO EL PROCESO DESDE EL ESTADO EJECUCION HASTA EL ESTADO TERMINADO, limite
* LLEVA EL NOMBRE O NUMERO DEL PROCESO*/
public void Ejecucion_Terminado(int limite){
orden1++;
NumProceso1++;
Color fondo=Cuadricula[7][17].getBackground();

for(int i=7,j=6;i>=1;i--,j--){
Cuadricula[i][17].setText(""+limite);
Cuadricula[i][17].setBackground(fondo);
Cuadricula[i][17].setVisible(true);
try {
Thread.sleep(100);
Cuadricula[j+1][17].setVisible(false);
}
catch (InterruptedException e){e.printStackTrace();}
}

for(int i=17;i<25;i++){
Cuadricula[1][i].setText(""+limite);
Cuadricula[1][i].setBackground(fondo);
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][24].setVisible(false);
/*COLOCANDO LOS PROCESOS TERMINADOS EN LA COLA DE TERMINADO, orden1 LLEVA LA
* POSICION DEL PROCESO EN LA COLA*/
switch(orden1)
{
case 1:
Cuadricula[8][24].setText(String.valueOf(limite));
Cuadricula[8][24].setBackground(fondo);
Cuadricula[8][24].setVisible(true);
break;
case 2:
Cuadricula[9][24].setText(String.valueOf(limite));
Cuadricula[9][24].setBackground(fondo);
Cuadricula[9][24].setVisible(true);
break;
case 3:
Cuadricula[10][24].setText(String.valueOf(limite));
Cuadricula[10][24].setBackground(fondo);
Cuadricula[10][24].setVisible(true);
break;
case 4:
Cuadricula[11][24].setText(String.valueOf(limite));
Cuadricula[11][24].setBackground(fondo);
Cuadricula[11][24].setVisible(true);
break;
case 5:
Cuadricula[12][24].setText(String.valueOf(limite));
Cuadricula[12][24].setBackground(fondo);
Cuadricula[12][24].setVisible(true);
break;
case 6:
Cuadricula[13][24].setText(String.valueOf(limite));
Cuadricula[13][24].setBackground(fondo);
Cuadricula[13][24].setVisible(true);
break;
case 7:
Cuadricula[14][24].setText(String.valueOf(limite));
Cuadricula[14][24].setBackground(fondo);;
Cuadricula[14][24].setVisible(true);
break;
case 8:
Cuadricula[15][24].setText(String.valueOf(limite));
Cuadricula[15][24].setBackground(fondo);
Cuadricula[15][24].setVisible(true);
break;
case 9:
Cuadricula[16][24].setText(String.valueOf(limite));
Cuadricula[16][24].setBackground(fondo);
Cuadricula[16][24].setVisible(true);
break;
case 10:
Cuadricula[17][24].setText(String.valueOf(limite));
Cuadricula[17][24].setBackground(fondo);
Cuadricula[17][24].setVisible(true);
break;
case 11:
Cuadricula[18][24].setText(String.valueOf(limite));
Cuadricula[18][24].setBackground(fondo);
Cuadricula[18][24].setVisible(true);
break;
case 12:
Cuadricula[19][24].setText(String.valueOf(limite));
Cuadricula[19][24].setBackground(fondo);
Cuadricula[19][24].setVisible(true);
break;
case 13:
Cuadricula[20][24].setText(String.valueOf(limite));
Cuadricula[20][24].setBackground(fondo);
Cuadricula[20][24].setVisible(true);
break;
case 14:
Cuadricula[21][24].setText(String.valueOf(limite));
Cuadricula[21][24].setBackground(fondo);
Cuadricula[21][24].setVisible(true);
break;
case 15:
Cuadricula[22][24].setText(String.valueOf(limite));
Cuadricula[22][24].setBackground(fondo);
Cuadricula[22][24].setVisible(true);
break;
case 16:
Cuadricula[23][24].setText(String.valueOf(limite));
Cuadricula[23][24].setBackground(fondo);
Cuadricula[23][24].setVisible(true);
break;
case 17:
Cuadricula[24][24].setText(String.valueOf(limite));
Cuadricula[24][24].setBackground(fondo);
Cuadricula[24][24].setVisible(true);
break;
case 18:
Cuadricula[25][24].setText(String.valueOf(limite));
Cuadricula[25][24].setBackground(fondo);
Cuadricula[25][24].setVisible(true);
break;
case 19:
Cuadricula[26][24].setText(String.valueOf(limite));
Cuadricula[26][24].setBackground(fondo);
Cuadricula[26][24].setVisible(true);
break;
case 20:
Cuadricula[27][24].setText(String.valueOf(limite));
Cuadricula[27][24].setBackground(fondo);
Cuadricula[27][24].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN DEL SWITCH*/
}/*FIN Ejecucion_Terminado*/
/*CREANDO UN NUEVO PROCESO Y MOVIENDO EL PROCESO CREADO DESDE EL ESTADO NUEVO HASTA LA COLA DE
* LSITO, LOS TRES PARAMETROS RECIBIDOS (int red, int green,int blue) PERTENECEN AL COLOR DE
* FONDO QUE HA DE TOMAR BOTON QUE REPRESENTE EL NUEVO PROCESO*/
public void Nuevo_Listo(int red, int green,int blue){
NumProceso++;
for(int i=1;i<8;i++){
Cuadricula[1][i].setText(""+NumProceso);
Cuadricula[1][i].setBackground(new Color(red,green,blue));
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][7].setVisible(false);
for(int i=1;i<8;i++){
Cuadricula[i][8].setText(""+NumProceso);
Cuadricula[i][8].setBackground(new Color(red,green,blue));
Cuadricula[i][8].setVisible(true);
Cuadricula[i-1][8].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[7][8].setVisible(false);
}/*FIN Nuevo_Listo*/
/*MOVIENDO EL PROCESO CREADO DESDE EL ESTADO DE LISTO HASTA LA COLA DE ESPERA
* LOS TRES PARAMETROS RECIBIDOS (int red, int green,int blue) PERTENECEN AL COLOR DE
* FONDO QUE HA DE TOMAR BOTON QUE REPRESENTA AL PROCESO*/
public void Listo_Cola(int red, int green,int blue){
orden++;
for(int i=7;i>=1;i--){
if (i>1){
Cuadricula[8][i].setText(""+NumProceso);
Cuadricula[8][i].setBackground(new Color(red,green,blue));
Cuadricula[8][i].setVisible(true);
}
if(i!=7)
Cuadricula[8][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
/*COLOCANDO EL PROCESO EN UNA POSICION ESPECIFICA DE LA CUADRICULA, orden
* GUARDA LA POSICION EN LA COLA*/
switch(orden)
{
case 1:
Cuadricula[8][1].setText(""+NumProceso);
Cuadricula[8][1].setBackground(new Color(red,green,blue));
Cuadricula[8][1].setVisible(true);
break;
case 2:
Cuadricula[9][1].setText(""+NumProceso);
Cuadricula[9][1].setBackground(new Color(red,green,blue));
Cuadricula[9][1].setVisible(true);
break;
case 3:
Cuadricula[10][1].setText(""+NumProceso);
Cuadricula[10][1].setBackground(new Color(red,green,blue));
Cuadricula[10][1].setVisible(true);
break;
case 4:
Cuadricula[11][1].setText(""+NumProceso);
Cuadricula[11][1].setBackground(new Color(red,green,blue));
Cuadricula[11][1].setVisible(true);
break;
case 5:
Cuadricula[12][1].setText(""+NumProceso);
Cuadricula[12][1].setBackground(new Color(red,green,blue));
Cuadricula[12][1].setVisible(true);
break;
case 6:
Cuadricula[13][1].setText(""+NumProceso);
Cuadricula[13][1].setBackground(new Color(red,green,blue));
Cuadricula[13][1].setVisible(true);
break;
case 7:
Cuadricula[14][1].setText(""+NumProceso);
Cuadricula[14][1].setBackground(new Color(red,green,blue));
Cuadricula[14][1].setVisible(true);
break;
case 8:
Cuadricula[15][1].setText(""+NumProceso);
Cuadricula[15][1].setBackground(new Color(red,green,blue));
Cuadricula[15][1].setVisible(true);
break;
case 9:
Cuadricula[16][1].setText(""+NumProceso);
Cuadricula[16][1].setBackground(new Color(red,green,blue));
Cuadricula[16][1].setVisible(true);
break;
case 10:
Cuadricula[17][1].setText(""+NumProceso);
Cuadricula[17][1].setBackground(new Color(red,green,blue));
Cuadricula[17][1].setVisible(true);
break;
case 11:
Cuadricula[18][1].setText(""+NumProceso);
Cuadricula[18][1].setBackground(new Color(red,green,blue));
Cuadricula[18][1].setVisible(true);
break;
case 12:
Cuadricula[19][1].setText(""+NumProceso);
Cuadricula[19][1].setBackground(new Color(red,green,blue));
Cuadricula[19][1].setVisible(true);
break;
case 13:
Cuadricula[20][1].setText(""+NumProceso);
Cuadricula[20][1].setBackground(new Color(red,green,blue));
Cuadricula[20][1].setVisible(true);
break;
case 14:
Cuadricula[21][1].setText(""+NumProceso);
Cuadricula[21][1].setBackground(new Color(red,green,blue));
Cuadricula[21][1].setVisible(true);
break;
case 15:
Cuadricula[22][1].setText(""+NumProceso);
Cuadricula[22][1].setBackground(new Color(red,green,blue));
Cuadricula[22][1].setVisible(true);
break;
case 16:
Cuadricula[23][1].setText(""+NumProceso);
Cuadricula[23][1].setBackground(new Color(red,green,blue));
Cuadricula[23][1].setVisible(true);
break;
case 17:
Cuadricula[24][1].setText(""+NumProceso);
Cuadricula[24][1].setBackground(new Color(red,green,blue));
Cuadricula[24][1].setVisible(true);
break;
case 18:
Cuadricula[25][1].setText(""+NumProceso);
Cuadricula[25][1].setBackground(new Color(red,green,blue));
Cuadricula[25][1].setVisible(true);
break;
case 19:
Cuadricula[26][1].setText(""+NumProceso);
Cuadricula[26][1].setBackground(new Color(red,green,blue));
Cuadricula[26][1].setVisible(true);
break;
case 20:
Cuadricula[27][1].setText(""+NumProceso);
Cuadricula[27][1].setBackground(new Color(red,green,blue));
Cuadricula[27][1].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Listo_Cola*/
public void actionPerformed(ActionEvent arg0) {
for(int i=0;i<25;i++){
for (int j=0;j<25;j++){
if (arg0.getSource().equals(Cuadricula[i][j])) {

}
}
}

}/*FIN actionPerformed*/
}/*FIN DE LA CLASE SimuladorPORTURNOS*/

Tags:

Clase Simulador

/*** ESTA CLASE SE UTILIZA PARA MOSTRAR EN PANTALLA LA SIMULACION DEL
* MOVIMIENTO DE LOS PORCESOS, SE USA UNA MATRIZ DE OBJETOS JTextField's
* PARA SIMULAR LOS PROCESOS Y SUS RESPECTIVOS ESTADOS */
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

public class Simulador extends JFrame implements ActionListener{
private JButton Cuadricula[][]=new JButton[30][25];
private JPanel PanelContenedor=new JPanel();
private int NumProceso=0;
private int NumProceso1=0;
private int orden=0,orden1=0;;
/*CONSTRUCTOR*/
public Simulador(){
PanelContenedor.setLayout(new GridLayout(30,25,0,0));
NumProceso1=NumProceso;
for(int i=0;i<30;i++){
for (int j=0;j<25;j++){
Cuadricula[i][j]=new JButton("");
Cuadricula[i][j].setVisible(false);
PanelContenedor.add(Cuadricula[i][j]);

if (i==8 && j==8){
Cuadricula[i][j].setText("L");
Cuadricula[i][j].setToolTipText("Estado LISTO");
Cuadricula[i][j].setVisible(true);
}
if (i==8 && j==17){
Cuadricula[i][j].setText("E");
Cuadricula[i][j].setToolTipText("Estado EJECUCION");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==0){
Cuadricula[i][j].setText("N");
Cuadricula[i][j].setToolTipText("Estado NUEVO");
Cuadricula[i][j].setVisible(true);
}
if (i==0 && j==24){
Cuadricula[i][j].setText("T");
Cuadricula[i][j].setToolTipText("Estado TERMINADO");
Cuadricula[i][j].setVisible(true);
}
}/*Termina FOR*/
}/*Termina FOR*/

getContentPane().add(PanelContenedor);

setSize(1000,800);
setResizable(true);
setVisible(true);
}/*FIN CONSTRUCTOR*/
/*MOVIENDO EL PROCESO DESDE EL ESTADO DE LISTO HASTA EL ESTADO DE EJECUCION
* SE RECIBE EN limite EL NUMERO DEL PROCESO QUE ES EQUIVALENTE A SU NOMBRE*/
public void Listo_Ejecucion(int limite){
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=8;i<=17;i++){
Cuadricula[7][i].setText(String.valueOf(limite));
Cuadricula[7][i].setBackground(fondo);
Cuadricula[7][i].setVisible(true);
Cuadricula[7][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
}/*FIN Listo_Ejecucion*/
/*MOVIENDOEL PROCESO DESDE ESTADO DE EJECUCION HASTA EL ESTADO DE LISTO, SE DEVUELVE EL COLOR
* DE FONDO PARA QUE SE PUEDA UTILIZAR EN LOS DEMAS MOVIMIENTOS, limite EQUIVALE AL NUMERO
* DEL PROCESO QUE SE ENCUENTRA EN MOVIMIENTO*/
public Color Ejecucion_Listo(int limite){
Cuadricula[7][17].setVisible(false);
Cuadricula[7+limite][1].setVisible(false);
Color fondo=Cuadricula[7+limite][1].getBackground();

for(int i=17;i>=8;i--){
Cuadricula[9][i].setText(String.valueOf(limite));
Cuadricula[9][i].setBackground(fondo);
Cuadricula[9][i].setVisible(true);
Cuadricula[9][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[7][8].setVisible(false);
Cuadricula[9][8].setVisible(false);

return(Cuadricula[7][8].getBackground());
}/*FIN Ejecucion_Listo*/
/*COLOCANDO LOS PROCESOS QUE SE ENCUENTRAN EN EL ESTADO LISTO, EN LA COLA RESPECTIVA
* limite EQUIVALE EL NUMERO DE PROCESO*/
public void Listo_Cola1(Color fondo,int limite){
Cuadricula[7][8].setVisible(false);
orden++;
for(int i=7;i>=1;i--){
if (i>1){
Cuadricula[8][i].setText(""+limite);
Cuadricula[8][i].setBackground(fondo);
Cuadricula[8][i].setVisible(true);
}
if(i!=7)
Cuadricula[8][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
/*EL SWITCH NOS AYUDA A COLOCAR LOS PROCESOS EN SUS POSICIONES RESPECTIVAS DENTRO DE LA COLA
*limite ES IGUAL AL NUMERO DEL PROCESO, Y TAMBIEN EL NUMERO DE POSICION EN RENGLONES DE
*LA CUADRICULA (LA COLA LISTO)*/
switch(limite)
{
case 1:
Cuadricula[8][1].setText(""+limite);
Cuadricula[8][1].setBackground(fondo);
Cuadricula[8][1].setVisible(true);
break;
case 2:
Cuadricula[9][1].setText(""+limite);
Cuadricula[9][1].setBackground(fondo);
Cuadricula[9][1].setVisible(true);
break;
case 3:
Cuadricula[10][1].setText(""+limite);
Cuadricula[10][1].setBackground(fondo);
Cuadricula[10][1].setVisible(true);
break;
case 4:
Cuadricula[11][1].setText(""+limite);
Cuadricula[11][1].setBackground(fondo);
Cuadricula[11][1].setVisible(true);
break;
case 5:
Cuadricula[12][1].setText(""+limite);
Cuadricula[12][1].setBackground(fondo);
Cuadricula[12][1].setVisible(true);
break;
case 6:
Cuadricula[13][1].setText(""+limite);
Cuadricula[13][1].setBackground(fondo);
Cuadricula[13][1].setVisible(true);
break;
case 7:
Cuadricula[14][1].setText(""+limite);
Cuadricula[14][1].setBackground(fondo);
Cuadricula[14][1].setVisible(true);
break;
case 8:
Cuadricula[15][1].setText(""+limite);
Cuadricula[15][1].setBackground(fondo);
Cuadricula[15][1].setVisible(true);
break;
case 9:
Cuadricula[16][1].setText(""+limite);
Cuadricula[16][1].setBackground(fondo);
Cuadricula[16][1].setVisible(true);
break;
case 10:
Cuadricula[17][1].setText(""+limite);
Cuadricula[17][1].setBackground(fondo);
Cuadricula[17][1].setVisible(true);
break;
case 11:
Cuadricula[18][1].setText(""+limite);
Cuadricula[18][1].setBackground(fondo);
Cuadricula[18][1].setVisible(true);
break;
case 12:
Cuadricula[19][1].setText(""+limite);
Cuadricula[19][1].setBackground(fondo);
Cuadricula[19][1].setVisible(true);
break;
case 13:
Cuadricula[20][1].setText(""+limite);
Cuadricula[20][1].setBackground(fondo);
Cuadricula[20][1].setVisible(true);
break;
case 14:
Cuadricula[21][1].setText(""+limite);
Cuadricula[21][1].setBackground(fondo);
Cuadricula[21][1].setVisible(true);
break;
case 15:
Cuadricula[22][1].setText(""+limite);
Cuadricula[22][1].setBackground(fondo);
Cuadricula[22][1].setVisible(true);
break;
case 16:
Cuadricula[23][1].setText(""+limite);
Cuadricula[23][1].setBackground(fondo);
Cuadricula[23][1].setVisible(true);
break;
case 17:
Cuadricula[24][1].setText(""+limite);
Cuadricula[24][1].setBackground(fondo);
Cuadricula[24][1].setVisible(true);
break;
case 18:
Cuadricula[25][1].setText(""+limite);
Cuadricula[25][1].setBackground(fondo);
Cuadricula[25][1].setVisible(true);
break;
case 19:
Cuadricula[26][1].setText(""+limite);
Cuadricula[26][1].setBackground(fondo);
Cuadricula[26][1].setVisible(true);
break;
case 20:
Cuadricula[27][1].setText(""+limite);
Cuadricula[27][1].setBackground(fondo);
Cuadricula[27][1].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Listo_Cola1*/
/*MOVIENDO EL PROCESO ACTUAL EN EJECUCION DESDE EL ESTADO EJECUCION HASTA EL ESTADO DE TERMINADO
* limite ES IGUAL AL NUMERO DEL PROCESO*/
public void Ejecucion_Terminado(int limite){
orden1++;
NumProceso1++;
Color fondo=Cuadricula[7][17].getBackground();

/*HACIENDO EL RECORRIDO POR LA CUADRICULA*/
for(int i=7,j=6;i>=1;i--,j--){
Cuadricula[i][17].setText(""+limite);
Cuadricula[i][17].setBackground(fondo);
Cuadricula[i][17].setVisible(true);
try {
Thread.sleep(100);
Cuadricula[j+1][17].setVisible(false);
}
catch (InterruptedException e){e.printStackTrace();}
}

for(int i=17;i<25;i++){
Cuadricula[1][i].setText(""+limite);
Cuadricula[1][i].setBackground(fondo);
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][24].setVisible(false);
/*EL SWITCH NOS AYUDA A COLOCAR LOS PROCESOS EN SUS POSICIONES RESPECTIVAS DENTRO DE LA COLA
*orden1 ES IGUAL AL NUMERO DEL PROCESO, Y TAMBIEN EL NUMERO DE POSICION EN RENGLONES DE
*LA CUADRICULA (LA COLA TERMINADO)*/
switch(orden1)
{
case 1:
Cuadricula[8][24].setText(String.valueOf(limite));
Cuadricula[8][24].setBackground(fondo);
Cuadricula[8][24].setVisible(true);
break;
case 2:
Cuadricula[9][24].setText(String.valueOf(limite));
Cuadricula[9][24].setBackground(fondo);
Cuadricula[9][24].setVisible(true);
break;
case 3:
Cuadricula[10][24].setText(String.valueOf(limite));
Cuadricula[10][24].setBackground(fondo);
Cuadricula[10][24].setVisible(true);
break;
case 4:
Cuadricula[11][24].setText(String.valueOf(limite));
Cuadricula[11][24].setBackground(fondo);
Cuadricula[11][24].setVisible(true);
break;
case 5:
Cuadricula[12][24].setText(String.valueOf(limite));
Cuadricula[12][24].setBackground(fondo);
Cuadricula[12][24].setVisible(true);
break;
case 6:
Cuadricula[13][24].setText(String.valueOf(limite));
Cuadricula[13][24].setBackground(fondo);
Cuadricula[13][24].setVisible(true);
break;
case 7:
Cuadricula[14][24].setText(String.valueOf(limite));
Cuadricula[14][24].setBackground(fondo);;
Cuadricula[14][24].setVisible(true);
break;
case 8:
Cuadricula[15][24].setText(String.valueOf(limite));
Cuadricula[15][24].setBackground(fondo);
Cuadricula[15][24].setVisible(true);
break;
case 9:
Cuadricula[16][24].setText(String.valueOf(limite));
Cuadricula[16][24].setBackground(fondo);
Cuadricula[16][24].setVisible(true);
break;
case 10:
Cuadricula[17][24].setText(String.valueOf(limite));
Cuadricula[17][24].setBackground(fondo);
Cuadricula[17][24].setVisible(true);
break;
case 11:
Cuadricula[18][24].setText(String.valueOf(limite));
Cuadricula[18][24].setBackground(fondo);
Cuadricula[18][24].setVisible(true);
break;
case 12:
Cuadricula[19][24].setText(String.valueOf(limite));
Cuadricula[19][24].setBackground(fondo);
Cuadricula[19][24].setVisible(true);
break;
case 13:
Cuadricula[20][24].setText(String.valueOf(limite));
Cuadricula[20][24].setBackground(fondo);
Cuadricula[20][24].setVisible(true);
break;
case 14:
Cuadricula[21][24].setText(String.valueOf(limite));
Cuadricula[21][24].setBackground(fondo);
Cuadricula[21][24].setVisible(true);
break;
case 15:
Cuadricula[22][24].setText(String.valueOf(limite));
Cuadricula[22][24].setBackground(fondo);
Cuadricula[22][24].setVisible(true);
break;
case 16:
Cuadricula[23][24].setText(String.valueOf(limite));
Cuadricula[23][24].setBackground(fondo);
Cuadricula[23][24].setVisible(true);
break;
case 17:
Cuadricula[24][24].setText(String.valueOf(limite));
Cuadricula[24][24].setBackground(fondo);
Cuadricula[24][24].setVisible(true);
break;
case 18:
Cuadricula[25][24].setText(String.valueOf(limite));
Cuadricula[25][24].setBackground(fondo);
Cuadricula[25][24].setVisible(true);
break;
case 19:
Cuadricula[26][24].setText(String.valueOf(limite));
Cuadricula[26][24].setBackground(fondo);
Cuadricula[26][24].setVisible(true);
break;
case 20:
Cuadricula[27][24].setText(String.valueOf(limite));
Cuadricula[27][24].setBackground(fondo);
Cuadricula[27][24].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Ejecucion_Terminado*/
/*MOVIENDO EL PROCESO DESDE EL ESTADO NUEVO HASTA EL ESTADO LISTO SE ENVIAN TRES PARAMETROS
* QUE PERTENECEN A LOS COMPONENTES DEL COLOR QUE TOMARA COMO FONDO EL BOTON QUE REPRESENTA AL
* PROCESO. no es necesario enviar el numero del proceso, batsa con el contador NumProceso,pues
* con solo irse encrementando de 1 en 1 es mas que suficiente para definir el numero o nombre
* del nuevo proceso creado */
public void Nuevo_Listo(int red, int green,int blue){
NumProceso++;/*numero de los procesos*/
for(int i=1;i<8;i++){
Cuadricula[1][i].setText(""+NumProceso);
Cuadricula[1][i].setBackground(new Color(red,green,blue));
Cuadricula[1][i].setVisible(true);
Cuadricula[1][i-1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[1][7].setVisible(false);
for(int i=1;i<8;i++){
Cuadricula[i][8].setText(""+NumProceso);
Cuadricula[i][8].setBackground(new Color(red,green,blue));
Cuadricula[i][8].setVisible(true);
Cuadricula[i-1][8].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
Cuadricula[7][8].setVisible(false);
}/*Fin Nuevo_Listo*/
/*MOVIENDO LOS PROCESOS DESDE EL ESTADO LISTO A LA COLA DE ESPERA, ESTA FUNCION SE EJECUTA CUANDO
* LOS PROCESOS APENAS HAN SIDO CREADOS*/
public void Listo_Cola(int red, int green,int blue){
orden++;
for(int i=7;i>=1;i--){
if (i>1){
Cuadricula[8][i].setText(""+NumProceso);
Cuadricula[8][i].setBackground(new Color(red,green,blue));
Cuadricula[8][i].setVisible(true);
}
if(i!=7)
Cuadricula[8][i+1].setVisible(false);

try {Thread.sleep(100);}
catch (InterruptedException e){e.printStackTrace();}
}
switch(orden)
{
case 1:
Cuadricula[8][1].setText(""+NumProceso);
Cuadricula[8][1].setBackground(new Color(red,green,blue));
Cuadricula[8][1].setVisible(true);
break;
case 2:
Cuadricula[9][1].setText(""+NumProceso);
Cuadricula[9][1].setBackground(new Color(red,green,blue));
Cuadricula[9][1].setVisible(true);
break;
case 3:
Cuadricula[10][1].setText(""+NumProceso);
Cuadricula[10][1].setBackground(new Color(red,green,blue));
Cuadricula[10][1].setVisible(true);
break;
case 4:
Cuadricula[11][1].setText(""+NumProceso);
Cuadricula[11][1].setBackground(new Color(red,green,blue));
Cuadricula[11][1].setVisible(true);
break;
case 5:
Cuadricula[12][1].setText(""+NumProceso);
Cuadricula[12][1].setBackground(new Color(red,green,blue));
Cuadricula[12][1].setVisible(true);
break;
case 6:
Cuadricula[13][1].setText(""+NumProceso);
Cuadricula[13][1].setBackground(new Color(red,green,blue));
Cuadricula[13][1].setVisible(true);
break;
case 7:
Cuadricula[14][1].setText(""+NumProceso);
Cuadricula[14][1].setBackground(new Color(red,green,blue));
Cuadricula[14][1].setVisible(true);
break;
case 8:
Cuadricula[15][1].setText(""+NumProceso);
Cuadricula[15][1].setBackground(new Color(red,green,blue));
Cuadricula[15][1].setVisible(true);
break;
case 9:
Cuadricula[16][1].setText(""+NumProceso);
Cuadricula[16][1].setBackground(new Color(red,green,blue));
Cuadricula[16][1].setVisible(true);
break;
case 10:
Cuadricula[17][1].setText(""+NumProceso);
Cuadricula[17][1].setBackground(new Color(red,green,blue));
Cuadricula[17][1].setVisible(true);
break;
case 11:
Cuadricula[18][1].setText(""+NumProceso);
Cuadricula[18][1].setBackground(new Color(red,green,blue));
Cuadricula[18][1].setVisible(true);
break;
case 12:
Cuadricula[19][1].setText(""+NumProceso);
Cuadricula[19][1].setBackground(new Color(red,green,blue));
Cuadricula[19][1].setVisible(true);
break;
case 13:
Cuadricula[20][1].setText(""+NumProceso);
Cuadricula[20][1].setBackground(new Color(red,green,blue));
Cuadricula[20][1].setVisible(true);
break;
case 14:
Cuadricula[21][1].setText(""+NumProceso);
Cuadricula[21][1].setBackground(new Color(red,green,blue));
Cuadricula[21][1].setVisible(true);
break;
case 15:
Cuadricula[22][1].setText(""+NumProceso);
Cuadricula[22][1].setBackground(new Color(red,green,blue));
Cuadricula[22][1].setVisible(true);
break;
case 16:
Cuadricula[23][1].setText(""+NumProceso);
Cuadricula[23][1].setBackground(new Color(red,green,blue));
Cuadricula[23][1].setVisible(true);
break;
case 17:
Cuadricula[24][1].setText(""+NumProceso);
Cuadricula[24][1].setBackground(new Color(red,green,blue));
Cuadricula[24][1].setVisible(true);
break;
case 18:
Cuadricula[25][1].setText(""+NumProceso);
Cuadricula[25][1].setBackground(new Color(red,green,blue));
Cuadricula[25][1].setVisible(true);
break;
case 19:
Cuadricula[26][1].setText(""+NumProceso);
Cuadricula[26][1].setBackground(new Color(red,green,blue));
Cuadricula[26][1].setVisible(true);
break;
case 20:
Cuadricula[27][1].setText(""+NumProceso);
Cuadricula[27][1].setBackground(new Color(red,green,blue));
Cuadricula[27][1].setVisible(true);
break;
default:
JOptionPane.showMessageDialog(null,"Solo se soportan 20 procesos");
}/*FIN SWITCH*/
}/*FIN Listo_Cola*/
public void actionPerformed(ActionEvent arg0) {
for(int i=0;i<25;i++){
for (int j=0;j<25;j++){
if (arg0.getSource().equals(Cuadricula[i][j])) {

}
}
}

}
}/*FIN DE LA CLAS Simulador*/

Tags:

Clase Procesos

public class Procesos {
private String StringNombre;
private int IntTiempoLlegada;
private int IntTiempoRafaga;
private int IntPrioridad;

public Procesos(String nombre,int TLLegada,int Trafaga,int Prioridad){
this.StringNombre=nombre;
this.IntTiempoLlegada=TLLegada;
this.IntTiempoRafaga=Trafaga;
this.IntPrioridad=Prioridad;
}

public int getIntPrioridad() {
return IntPrioridad;
}

public void setIntPrioridad(int intPrioridad) {
IntPrioridad = intPrioridad;
}

public int getIntTiempoLlegada() {
return IntTiempoLlegada;
}

public void setIntTiempoLlegada(int intTiempoLlegada) {
IntTiempoLlegada = intTiempoLlegada;
}

public int getIntTiempoRafaga() {
return IntTiempoRafaga;
}

public void setIntTiempoRafaga(int intTiempoRafaga) {
IntTiempoRafaga = intTiempoRafaga;
}

public String getStringNombre() {
return StringNombre;
}

public void setStringNombre(String stringNombre) {
StringNombre = stringNombre;
}
}

Tags:

Clase Algoritmo por Prioridades

import java.util.Arrays;
import java.util.Vector;

public class Prioridades {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE EVALUAN LAS PRIORIDADES
QUE SE LE ASIGNARON A LOS PROCESOS, Y EJECUTA EL PROCESO DE MAYOR PRIORIDAD =1*/
Vector VectorProcesos;
private int DoubleTiempoEspera;
private double DoubleTiempoEspera1;
Arrays vector;
private int vectoraux[];
private int NumeroProceso[];
private int VectorPrioridad[];
private String ProcesosNombres[];
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public Prioridades(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
vectoraux=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
VectorPrioridad=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public void getTiempoEsperaPromedio(){
int i=0;
for (i=0;i vectoraux[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
VectorPrioridad[i]=((Procesos)VectorProcesos.elementAt(i)).getIntPrioridad();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
}
ordena(); /*ordenando los procesos*/
for (i=0;i System.out.println(ProcesosNombres[i]+">>"+vectoraux[i]+">>"+VectorPrioridad[i]);
}

DoubleTiempoEspera=vectoraux[0];
for (i=1;i DoubleTiempoEspera+=vectoraux[i];
vectoraux[i]=DoubleTiempoEspera;
}

DoubleTiempoEspera1=0;
for (i=0;i DoubleTiempoEspera1+=vectoraux[i];
}

DoubleTiempoEspera1=DoubleTiempoEspera1/VectorProcesos.size();
System.out.println(DoubleTiempoEspera1);
}

public void ordena(){
int aux,aux2,aux3,k,i;
String aux1;

for(i=1;i aux =VectorPrioridad[i];
aux2=vectoraux[i];
aux1= ProcesosNombres[i];
aux3=NumeroProceso[i];
k=i-1;
while (k >= 0 && aux < VectorPrioridad[k]){
vectoraux[k+1] = vectoraux[k];
ProcesosNombres[k+1]=ProcesosNombres[k];
VectorPrioridad[k+1]=VectorPrioridad[k];
NumeroProceso[k+1]=NumeroProceso[k];
k=k-1;
}
vectoraux[k+1] = aux2;
VectorPrioridad[k+1]=aux;
ProcesosNombres[k+1]=aux1;
NumeroProceso[k+1]=aux3;
}
}

public int[] getValores(){
return vectoraux;
}
/*DEVULEVE LOS NOMBRES DE LOS PROCESOS*/
public String []getNombre(){
return ProcesosNombres;
}
/*DEVUELVE LOS NUMEROS DE PROCESO*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*DEVUELVE LOS RESULTADOS*/
public double imprimeResultado(){
return DoubleTiempoEspera1;
}

}

Tags:

Clase algoritmo PorTurnos

import java.util.Vector;
import javax.swing.*;

public class PorTurnos {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE NECESITA DAR UN QUANTUM DE TIEMPO
YA QUE EL ALGORITMO EJECUTA CADA PROCESO EN ESE TIEMPO Y PASA AL SIGUIENTE PROCESO
Y ASI SUCESIVAMENTE HASTA LLEGAR AL ULTIMO PROCESO Y VUELVE AL INICIO Y CUANDO
EL PROCESO YA TERMINA, SE VA SALIENDO*/
private int []TRafaga;
private int []RealTRafaga;
private int tamano=0;
private int Quantum=4;
private int []NewTRafaga =new int[30];
private int []NewTRafaga1;
private int NumeroProceso[];
private String []ProcesosNombres;
private String []NewNombres=new String[30];
private String []NewNombres1;
private double DoubleTiempoEspera1;
Vector VectorProcesos;
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public PorTurnos(Vector VectorProcesos){
this.VectorProcesos=VectorProcesos;
TRafaga=new int[VectorProcesos.size()];
RealTRafaga=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
Quantum=Integer.parseInt(JOptionPane.showInputDialog(null,"Introduzca el valor del Quantum"));
for (int i=0;i TRafaga[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
RealTRafaga[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
}
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public void getTiempoEspera(){
int mayor,valor,j=1,p=0,numQuantum=1;
String proceso;

mayor=TRafaga[0];/*Calculando el mayor*/
for (int i=0;i NewTRafaga[i]=-1;
}
for (int i=0;i if (mayor mayor=TRafaga[i];
}
}
NewTRafaga[0]=0;
valor=(mayor/Quantum);
for (int h=0;h for (int i=0;i if(TRafaga[i]!=0){
if(Quantum>TRafaga[i]){
NewTRafaga[j]=NewTRafaga[j-1]+TRafaga[i];
NewNombres[j-1]=ProcesosNombres[i];
TRafaga[i]=0;
j++;
}
else{
TRafaga[i]-=Quantum;
NewTRafaga[j]=NewTRafaga[j-1]+Quantum;
NewNombres[j-1]=ProcesosNombres[i];
j++;
}
}
}
}
for (int i=0;i if(NewTRafaga[i]!=-1){
tamano++;
}
}
NewTRafaga1 =new int[tamano];
NewNombres1=new String[tamano];
for(int z=0;z if(z NewTRafaga1[z]=NewTRafaga[z];
NewNombres1[z]=NewNombres [z];
}
else
break;
}

int numeroRepeticiones=0;
int UltimaPosicion=1;
DoubleTiempoEspera1=0;
double temporalT;

for(int i=0;i proceso=NewNombres1[i];
numeroRepeticiones=0;
for(int k=0;k
if(proceso==NewNombres1[k]){
numeroRepeticiones+=1;
UltimaPosicion=k;
}
}
temporalT=(numeroRepeticiones-1)*Quantum;
DoubleTiempoEspera1+=Math.abs(NewTRafaga1[UltimaPosicion]-temporalT);//Math.abs(TiempoRafaga[1]-nuevoQuantum);
}/*Fin FOR*/
DoubleTiempoEspera1=DoubleTiempoEspera1/VectorProcesos.size();
}
/*SE DEVUELVE EL TIEMPO DE RAFAGA*/
public int[] getValores() {
return NewTRafaga1;
}
/* SE DEVULVE LA NUEVA LA LONGITUD PARA EL VECTOR QUE CONTIENE LOS NUEVOS TIEMPOS DE RAFAGA*/
public int getTamano(){
return tamano;
}
/*SE DEVUELVE EL QUANTUM DE TIEMPO*/
public int getQuantum(){
return Quantum;
}
/*SE DEVUELVE EL VECTOR CON LOS NOMBRES DE LOS PROCESOS*/
public String[] getNombre() {
return NewNombres1;
}
/*SE DEVULVE EL TIEMPO PROMEDIO DE ESPERA*/
public double getTEP(){
return DoubleTiempoEspera1;
}
/*SE DEVUELVE LOS NUMEROS DE PROCESOS*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*DEVUELVE EL TIEMPO DE RAFAGA, EL QUE TRAE REGISTRADO DESDE QUE SE CREA EL PROCESO */
public int []gerRealTRafaga(){
return RealTRafaga;
}
/*IMPRIME EL TIEMPO PROMEDIO DE ESPERA*/
public void imprimeResultado() {
System.out.println(DoubleTiempoEspera1);
}
}

Tags:

Clase HiloPorTurnos

/*ESTA CLASE HACE LA SIMULACION CON SU RESPECTIVO TIEMPO DE RETARDO
*UNICAMENTE PARA EL ALGORITMO POR TURNOS*/
import java.awt.Color;
import javax.swing.*;
public class HiloPorTurnos extends Thread {
int retardo;
int valorNew;
int limite=1;
int numeroProceso[];
int red,green,blue;
private int Quantum;
String nombre;
String Titulo;
JButton p1;
Simulador sim;
int tiempo;
int valores [];
private int RealTRafaga[];
/*CONSTRCUTOR. SE RECIBEN LOS TIEMPOS DE RAGAFA, NUMEROS O NOMBRES DE LOS PROCESOS,EL QUANTUM
* Y UN VECTOR ADICIONAL CON EL VERDADERO TIEMPO DE RAGAFA DE CADA PROCESO*/
public HiloPorTurnos(int []valores1,int [] NumeroProceso,String Title,int Quantum,int []RealTRafaga1){
this.valores=valores1;
this.Titulo=Title;
this.numeroProceso=NumeroProceso;
this.RealTRafaga=RealTRafaga1;
this.Quantum=Quantum;
sim=new Simulador();
sim.setExtendedState(SimuladorPORTURNOS.MAXIMIZED_BOTH);
tiempo = 0;
}/*FINCONSTRUCTOR*/
/*FUNCION RUN. SE ENCARGA DE EJECUTAR LA SIMULACION CON SU RESPECTIVO
* TIEMPO DE RETARDO, DESDE AQUI SE LLAMAN A LOS METODOS DE LA CLASE
* SimuladorPORTURNOS, QUE HACEN EL MOVIMIENTO DE LOS PROCESOS*/
public void run(){
while (limite<=numeroProceso.length) {
red=(int)(Math.random()*256);
green=(int)(Math.random()*256);
blue=(int)(Math.random()*256);
try {
sim.setTitle(" Simulación del algoritmo "+Titulo);
sim.Nuevo_Listo(red,green,blue);
sim.Listo_Cola(red,green,blue);
Thread.sleep(300);
tiempo = tiempo + 300;
limite++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
/*Ejecutando los procesos*/
limite=0;
while(true){
try{
sim.setTitle(" Simulación del algoritmo "+Titulo);
if (numeroProceso[limite]!=0)
sim.Listo_Ejecucion(numeroProceso[limite]);

valorNew=RealTRafaga[limite]-Quantum;
RealTRafaga[limite]=valorNew;
if (valorNew<=0 && numeroProceso[limite]!=0){
Thread.sleep(valores[limite]*100);
sim.Ejecucion_Terminado(numeroProceso[limite]);
numeroProceso[limite]=0;
}
else {
if (numeroProceso[limite]!=0){
Thread.sleep(Quantum*100);
Color fondo=sim.Ejecucion_Listo(numeroProceso[limite]);
sim.Listo_Cola1(fondo,limite+1);
}
}
tiempo = tiempo + 300;
} catch (InterruptedException e)
{
e.printStackTrace();
}
if (limite==numeroProceso.length-1)
limite=0;
else
limite++;

}/*Fin del ciclo que ejecuta los procesos*/
}/*Fin funcion RUN*/
}/*FIN DE LA CLASE HiloPorTurnos*/

Tags:

Clase Hilo

/*ESTA CLASE ES LA QUE HACE GRAN PARTE DE LA SIMULACION PARA LOS ALGORITMOS>
* -- FCFS
* -- SJF COOPERATIVO
* -- POR PRIORIDADES
*/
import javax.swing.*;
public class Hilo extends Thread {
int retardo;
int limite=1;
int numeroProceso[];
int red,green,blue;
String nombre;
String Titulo;
JButton p1;
Simulador sim;
int tiempo;
int valores [];
/*CONSTRUCTOR RECIBE LOS VALORES DE RAFAGA, LOS NMEROS DE LOS PROCESOS
* Y EL NOMBRE DEL ALGORITMO*/
public Hilo(int []valores1,int [] NumeroProceso,String Title){
this.valores=valores1;
this.Titulo=Title;
this.numeroProceso=NumeroProceso;
sim=new Simulador();
sim.setExtendedState(Simulador.MAXIMIZED_BOTH);
tiempo = 0;
}/*FIN CONSTRUCTOR*/
/*FUNCION RUN. SE ENCARGA DE EJECUTAR LA SIMULACION CON SU RESPECTIVO
* TIEMPO DE RETARDO, DESDE AQUI SE LLAMAN A LOS METODOS DE LA CLASE
* Simulador, QUE HACEN EL MOVIMIENTO DE LOS PROCESOS*/
public void run(){
while (limite<=valores.length) {
red=(int)(Math.random()*256);
green=(int)(Math.random()*256);
blue=(int)(Math.random()*256);
try {
sim.setTitle(" Simulación del algoritmo "+Titulo);
sim.Nuevo_Listo(red,green,blue);
sim.Listo_Cola(red,green,blue);
Thread.sleep(300);
tiempo = tiempo + 300;
limite++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
/*Ejecutando los procesos*/
limite=0;
while(limite try{
sim.setTitle(" Simulación del algoritmo "+Titulo);
sim.Listo_Ejecucion(numeroProceso[limite]);
Thread.sleep(valores[limite]*100);
sim.Ejecucion_Terminado(numeroProceso[limite]);

tiempo = tiempo + 300;
limite++;
} catch (InterruptedException e)
{
e.printStackTrace();
}
}/*Fin del ciclo que ejecuta los procesos*/
}/*Fin funcion RUN*/
}/*FIN DE LA CLASE Hilo*/

Tags:

Algoritmo FCFS

import java.util.*;
public class FCFS {
/*ESTA CLASE RECIBE UN VECTOR CON TODOS LOS DATOS QUE SE NECESITAN PARA
EMPEZAR A EJECUTAR EL ALGORITMO, EN ESTE SE EMPIEZAN A
EJECUTAR LOS PROCESOS A COMO FUERON LLEGANDO*/
Vector VectorProcesos;
private double DoubleTiempoEspera=0;
private int DoubleTiempoEspera1=0;
private int vectoraux[];
private int NumeroProceso[];
private String ProcesosNombres[];
private double vectoraux1[];
/*EN EL CONTRUCTOR SE RECIBE EL VECTOR CON TODOS LOS DATOS DE LOS PROCESOS*/
public FCFS(Vector VectorProcesos){
this.VectorProcesos = VectorProcesos;
vectoraux=new int[VectorProcesos.size()];
NumeroProceso=new int[VectorProcesos.size()];
ProcesosNombres=new String[VectorProcesos.size()];
vectoraux1=new double[VectorProcesos.size()];
}
/*EN ESTA PARTE SE CALCULA EL TIEMPO PROMEDIO DE ESPERA DEL ALGORTIMO*/
public double getTiempoEsperaPromedio(){
for (int i=0;i DoubleTiempoEspera+=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
DoubleTiempoEspera1+=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoRafaga();
ProcesosNombres[i]=((Procesos)VectorProcesos.elementAt(i)).getStringNombre();
NumeroProceso[i]=((Procesos)VectorProcesos.elementAt(i)).getIntTiempoLlegada()+1;
vectoraux[i]=DoubleTiempoEspera1;
vectoraux1[i]=DoubleTiempoEspera;
}
DoubleTiempoEspera=0;
for (int i=0;i DoubleTiempoEspera+=vectoraux1[i];
}
DoubleTiempoEspera=DoubleTiempoEspera/VectorProcesos.size();
return DoubleTiempoEspera;
}
/*SE DEVUELVEN LOS TIEMPOS DE RAFAGA*/
public int[] getValores(){
return vectoraux;
}
/*SE DEVUELVEN EL TIEMPO DE RAFAGA*/
public String[] getNombre(){
return ProcesosNombres;
}
/*SE DEVUELVE EL NUMERO DE PROCESO*/
public int[] getNumeroProceso(){
return NumeroProceso;
}
/*SE DEVUELVE EL TIEMPO PROMEDIO DE ESPERA*/
public double imprimeResultado(){
System.out.println(DoubleTiempoEspera);
return DoubleTiempoEspera;
}

}

Tags:

Clase DiagramaGantt

/**ESTA CLASE HACE EL DIBUJO DEL DIAGRAMA DE GANTT PARA
* CADA ALGORITMO EJECUTADO*/
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridLayout;
import java.awt.LayoutManager;
import java.util.Vector;
import javax.swing.*;

public class DiagramaGantt extends JFrame{
Vector VectorProcesos=new Vector();/*el vector que va a contener todos los procesos creados*/
private JPanel PanelDiagrama=new JPanel();/*en este panel se dibujará el diagrama de gantt*/
private JPanel PanelTEP;/*en este panel se mostrará el Tiempo promedio de espera*/
private JLabel GanttBotones[];
private JLabel GanttEtiquetas[];
private GridLayout GridBotonesEtiquetas;
private double TiempEsperaPromedio;

/*CONSTRUCTOR*/
public DiagramaGantt(Vector VectorProcesos,String algoritmo){
this.setTitle("Diagrama de Gantt '"+algoritmo+"'");
this.VectorProcesos=VectorProcesos;
GanttBotones=new JLabel[(VectorProcesos.size()*2)+1];
GanttEtiquetas=new JLabel[(VectorProcesos.size()*2)+1];

PanelTEP=new JPanel();
PanelTEP.setLayout(new BorderLayout());
this.setLayout(new GridLayout(2,1,0,0));
}/*FIN DEL CONSTRUCTOR*/

/*ESTA FUNCION CREA EL DIAGRAMA DE GANTT PARA EL ALGORITMO SOLICITADO*/
public void crearDiagrama(int [] vectoraux,String [] ProcesosNombres1,double TEP){
GridBotonesEtiquetas = new GridLayout(2, (VectorProcesos.size()*2)+1, 5, 5);
PanelDiagrama.setLayout(GridBotonesEtiquetas);

this.TiempEsperaPromedio=TEP;
int j=0;
int vectorux[]=vectoraux;
String ProcesosNombres[]=ProcesosNombres1;

/*CREANDO LAS ETIQUETAS CON LOS NOMBRES DE LOS PROCESOS*/
for (int i=0;i<(VectorProcesos.size()*2)+1;i++){
if (i%2!=0){
GanttBotones[i]=new JLabel(ProcesosNombres[j]);
GanttBotones[i].setBorder(BorderFactory.createLineBorder(Color.BLUE, 2));
GanttBotones[i].setFont(new Font("Arial", Font.BOLD, 14));
GanttBotones[i].setHorizontalAlignment(JLabel.CENTER);
PanelDiagrama.add(GanttBotones[i]);
j++;
}
else{
GanttBotones[i]=new JLabel("");
GanttBotones[i].setVisible(false);
PanelDiagrama.add(GanttBotones[i]);
}
}
JLabel PrimerElemento=new JLabel("0");
PrimerElemento.setFont(new Font("Arial", Font.BOLD, 14));
GanttEtiquetas[0]=PrimerElemento;
PanelDiagrama.add(GanttEtiquetas[0]);
j=0;
/*CREANDO LAS ETIQUETAS CON LAS LEYENDAS DE LOS TIEMPOS DE
* RAFAGA RESPECTIVOS PARA CADA PROCESO*/
for (int i=1;i<(VectorProcesos.size()*2)+1;i++){
if(i%2==0){
String datos=new String(String.valueOf(vectorux[j]));
GanttEtiquetas[j+1]=new JLabel(datos);
GanttEtiquetas[j+1].setFont(new Font("Arial", Font.BOLD, 14));
PanelDiagrama.add(GanttEtiquetas[j+1]);
j++;
}
else{
GanttEtiquetas[i]=new JLabel("");
GanttEtiquetas[i].setVisible(false);
PanelDiagrama.add(GanttEtiquetas[i]);
}
}
/*COLOCANDO LA LEYENDA CON EL TIEMPO DE ESPERA PROMEDIO*/
JLabel LabelTEP=new JLabel("Tiempo de Espera Promedio = "+String.valueOf(TiempEsperaPromedio));
LabelTEP.setFont(new Font("Arial", Font.BOLD, 14));
PanelTEP.add(LabelTEP,BorderLayout.SOUTH);
getContentPane().add(PanelDiagrama);
getContentPane().add(PanelTEP);
setSize(400, 100);
setVisible(true);
setResizable(true);
}/*FIN DE LA FUNCION crearDiagrama*/

/*ESTA FUNCION SIRVE PARA CREAR EL DIAGRAMA DEL ALORITMO POR TURNOS*/
public void crearDiagramaPorTurnos(int [] vectoraux1,int tamano,String [] ProcesosNombres1,double TiempoEspera){
GridBotonesEtiquetas = new GridLayout(2, (tamano*2)+1, 5, 5);
PanelDiagrama.setLayout(GridBotonesEtiquetas);

GanttBotones=new JLabel[(tamano*2)+1];
GanttEtiquetas=new JLabel[(tamano*2)+1];

int j=0;
int vectorux[]=vectoraux1;
/*CREANDO LAS ETIQUETAS CON LOS NOMBRES DE LOS PROCESOS*/
for (int i=0;i<(tamano*2)-1;i++){
if (i%2!=0){
GanttBotones[i]=new JLabel(ProcesosNombres1[j]);
GanttBotones[i].setBorder(BorderFactory.createLineBorder(Color.BLUE, 2));
GanttBotones[i].setHorizontalAlignment(JLabel.CENTER);
PanelDiagrama.add(GanttBotones[i]);
j++;
}
else{
GanttBotones[i]=new JLabel("");
GanttBotones[i].setVisible(false);
PanelDiagrama.add(GanttBotones[i]);
}

}
j=0;
/*CREANDO LAS ETIQUETAS CON LAS LEYENDAS DE LOS TIEMPOS DE
* RAFAGA RESPECTIVOS PARA CADA PROCESO*/
for (int i=1;i<(tamano*2)+1;i++){
if(i%2==0){
String datos=new String(String.valueOf(vectorux[j]));
GanttEtiquetas[j]=new JLabel(datos);
PanelDiagrama.add(GanttEtiquetas[j]);
j++;
}
else{
GanttEtiquetas[i]=new JLabel("");
GanttEtiquetas[i].setVisible(false);
PanelDiagrama.add(GanttEtiquetas[i]);
}
}
/*COLOCANDO LA LEYENDA CON EL TIEMPO DE ESPERA PROMEDIO*/
JLabel LabelTEP=new JLabel("Tiempo de Espera Promedio = "+String.valueOf(TiempoEspera));
LabelTEP.setFont(new Font("Arial", Font.BOLD, 14));
PanelTEP.add(LabelTEP,BorderLayout.SOUTH);
getContentPane().add(PanelDiagrama);
getContentPane().add(PanelTEP);
setSize(400, 100);
setVisible(true);
setResizable(true);
}/* FIN DE LA FUNCION crearDiagramaPorTurnos*/
}/*FIN DE LA CLASE DiagramaGantt*/

Tags:

Clase Aplicacion

/** CLASE PRINCIPAL, DESDE AQUI SE HACEN LAS LLAMADAS A TODOS LOS EVENTOS
* QUE EJECUTA EL SISTEMA, COMO SON:
* --AGREGAR PROCESOS
* --ELIMINAR O MODIFICAR PROCESOS
* --HACER LA LLAMADA PARA EJECUTAR LOS ALGORITMOS*/
import java.awt.*;
import java.awt.event.*;
import java.util.Vector;
import javax.swing.*;

public class Aplicacion extends JFrame implements ActionListener{
private JMenu JMenuProcesos,JMenuAlgoritmos;
private JMenuItem JMenuFCFS,JMenuSJFCooperativo,JMenuSJFApropiativo,JMenuPrioridades,JMenuTurnos;
private JMenuItem JMenuAgregar,JMenuEliminarEditar,JMenuSalir;
private JLabel fondo;
Vector VectorProcesos=new Vector();/*el vector que va a contener todos los procesos creados*/

public Aplicacion(){
super("SISTEMA CON ALGORITMOS DE PLANIFICACION");
setSize(1180,870);
fondo= new JLabel(new ImageIcon("linux.jpg"));
getContentPane().add(fondo);

JMenuProcesos=new JMenu("Procesos");
JMenuAlgoritmos=new JMenu("Algoritmos");

/************************************************************/
/******** ******************/
/******** CONTENIDO DEL MENU PROCESOS ******************/
/******** ******************/
/************************************************************/
JMenuAgregar=new JMenuItem("Agregar un proceso",new ImageIcon("agrega.png"));
JMenuAgregar.addActionListener(this);
JMenuEliminarEditar=new JMenuItem("Eliminar / Modificar Procesos",new ImageIcon("elim.png"));
JMenuEliminarEditar.addActionListener(this);
JMenuSalir=new JMenuItem("Salir del sistema",new ImageIcon("exit.png"));
JMenuSalir.addActionListener(this);

JMenuProcesos.add(JMenuAgregar);
JMenuProcesos.add(JMenuEliminarEditar);JMenuProcesos.addSeparator();
JMenuProcesos.add(JMenuSalir);

/************************************************************/
/******** ******************/
/******** CONTENIDO DEL MENU ALGORITMOS ******************/
/******** ******************/
/************************************************************/
JMenuFCFS=new JMenuItem("FCFS",new ImageIcon("I1.png"));
JMenuFCFS.addActionListener(this);
JMenuSJFCooperativo=new JMenuItem("SJF Cooperativo",new ImageIcon("I2.png"));
JMenuSJFCooperativo.addActionListener(this);
JMenuSJFApropiativo=new JMenuItem("SJF Apropiativo",new ImageIcon("I4.png"));
JMenuSJFApropiativo.addActionListener(this);
JMenuPrioridades=new JMenuItem("Por prioridades",new ImageIcon("I3.png"));
JMenuPrioridades.addActionListener(this);
JMenuTurnos=new JMenuItem("Por Turnos",new ImageIcon("I5.png"));
JMenuTurnos.addActionListener(this);


JMenuAlgoritmos.add(JMenuFCFS);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuSJFCooperativo);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuSJFApropiativo);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuPrioridades);JMenuAlgoritmos.addSeparator();
JMenuAlgoritmos.add(JMenuTurnos);

JMenuBar barra=new JMenuBar();
setJMenuBar(barra);
barra.add(JMenuProcesos);
barra.add(JMenuAlgoritmos);
setVisible(true);
}/*FIN DEL CONSTRUCTOR*/

/*MANEJO DE LOS EVENTOS PARA LOS MSUBMENUS DEL SISTEMA*/
public void actionPerformed(ActionEvent arg0) {
/*LLAMADA A LA VENTANA PARA AGREGAR LOS PROCESOS*/
if (arg0.getSource().equals(JMenuAgregar)) {
VentanaAgregaProcesos agrega=new VentanaAgregaProcesos(VectorProcesos);
agrega.setLocationRelativeTo(null);
}
/*LLAMADA A LA VENTANA QUE MODIFICA O ELIMINA LOS PROCESOS*/
if (arg0.getSource().equals(JMenuEliminarEditar)) {
if (!VectorProcesos.isEmpty()){
VentanaEliminaModificaProcesos EliminaEdita=new VentanaEliminaModificaProcesos(VectorProcesos);
EliminaEdita.setLocationRelativeTo(null);
}
else{
int respuesta=JOptionPane.showConfirmDialog(null,"No existen procesos almacenados. \n\n Desea abrir la ventana de captura ahora?","No hay procesos",JOptionPane.YES_NO_OPTION,JOptionPane.WARNING_MESSAGE);

if(respuesta==JOptionPane.YES_OPTION){
VentanaAgregaProcesos agrega=new VentanaAgregaProcesos(VectorProcesos);
agrega.setLocationRelativeTo(null);
}
}
}
/*SALIENDO DEL PROGRAMA*/
if (arg0.getSource().equals(JMenuSalir)) {
System.exit(0);
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO FCFS*/
if (arg0.getSource().equals(JMenuFCFS)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
FCFS fcfs=new FCFS(VectorProcesos);
fcfs.getTiempoEsperaPromedio();
Hilo grafHilo = new Hilo(fcfs.getValores(),fcfs.getNumeroProceso(),"FCFS");
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"FSFS");
gantt.setLocationRelativeTo(null);
gantt.crearDiagrama(fcfs.getValores(),fcfs.getNombre(),fcfs.imprimeResultado());

}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO SJF Cooperativo*/
if (arg0.getSource().equals(JMenuSJFCooperativo)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
SJFCooperativo sjfcooperativo=new SJFCooperativo(VectorProcesos);
sjfcooperativo.getTiempoEsperaPromedio();
sjfcooperativo.imprimeResultado();
Hilo grafHilo = new Hilo(sjfcooperativo.getValores(),sjfcooperativo.getNumeroProceso(),"SJF Cooperativo");
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"SJF Cooperativo");
gantt.setLocationRelativeTo(null);
gantt.crearDiagrama(sjfcooperativo.getValores(),sjfcooperativo.getNombre(),sjfcooperativo.imprimeResultado());
}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO SJF Apropiativo*/
if (arg0.getSource().equals(JMenuSJFApropiativo)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
JOptionPane.showMessageDialog(null,"ESTA FUNCION AUN NO SE HA DESARROLLADO ","UPPPS.",JOptionPane.WARNING_MESSAGE);
}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO "POR PRIORIDADES"*/
if (arg0.getSource().equals(JMenuPrioridades)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
Prioridades prioridad=new Prioridades(VectorProcesos);
prioridad.getTiempoEsperaPromedio();

Hilo grafHilo = new Hilo(prioridad.getValores(),prioridad.getNumeroProceso(),"Por Prioridades");
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"Por Prioridades");
gantt.setLocationRelativeTo(null);
gantt.crearDiagrama(prioridad.getValores(),prioridad.getNombre(),prioridad.imprimeResultado());
}
}
/*HACIENDO LA LLAMADA PARA EL ALGORITMO "POR TURNOS"*/
if (arg0.getSource().equals(JMenuTurnos)) {
if(VectorProcesos.isEmpty()){
JOptionPane.showMessageDialog(null,"No existen procesos almacenados. \n Debe almacenar almenos dos procesos para ejecutar este algoritmo.","No hay procesos almacenados",JOptionPane.WARNING_MESSAGE);
}else{
PorTurnos turno=new PorTurnos(VectorProcesos);
turno.getTiempoEspera();
turno.imprimeResultado();
HiloPorTurnos grafHilo = new HiloPorTurnos(turno.getValores(),turno.getNumeroProceso(),"Por Turnos",turno.getQuantum(),turno.gerRealTRafaga());
grafHilo.start();

DiagramaGantt gantt=new DiagramaGantt(VectorProcesos,"Por Turnos");
gantt.setLocationRelativeTo(null);
gantt.crearDiagramaPorTurnos(turno.getValores(),turno.getTamano(),turno.getNombre(),turno.getTEP());
}

}
}/*FIN DE ACTION PERFORMED*/

public static void main(String[] args) {
/*PARA QUE LAS PANTALLAS DEL PROGRAMA TOMEN LA APARIENCIA DEL TEMA
* DEL SISTEMA OPERATIVO*/
// try {
// UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
// } catch (Exception e){}

Aplicacion Algoritmos=new Aplicacion();
Algoritmos.setExtendedState(Aplicacion.MAXIMIZED_BOTH);
Algoritmos.setDefaultCloseOperation(Aplicacion.EXIT_ON_CLOSE);
}/*FIN DEL MAIN*/
}/*FIN CLASE APLICACION*/

Tags: