Ejercicio de Simulación de Colas en Java

En este ejercicio vamos a estudiar la simulación de una cola simple utilizando Java. Los elementos llegan aleatoriamente al sistema, esperan su turno y posteriormente son atendidos durante un tiempo de servicio también aleatorio.

Este ejemplo permite estudiar de forma práctica conceptos fundamentales de Programación Orientada a Objetos (POO), utilización de vectores, clases, objetos, herencia, interfaces y representación gráfica utilizando las clases de Java AWT.

Objetivo de la simulación Representar el comportamiento de una cola donde diferentes elementos llegan en determinados instantes de tiempo, esperan hasta poder ser procesados y permanecen ocupando el recurso durante un tiempo determinado.

1. Clase Elemento

Para representar cada uno de los elementos que llegan a la cola se utiliza la clase Elemento.

Esta clase contiene tres variables miembro:

• creado: almacena el instante de tiempo en el que el elemento llega a la cola.
• inicioProceso: almacena el instante en el que comienza a ser atendido.
• tiempoProceso: indica cuánto tiempo dura la atención o procesamiento del elemento.

La clase también incorpora un constructor que genera el instante de llegada y el método Dibujar, encargado de representar gráficamente la vida del elemento dentro del sistema.

La representación gráfica utiliza una escala de 5 píxeles por unidad de tiempo.

Elemento.java JAVA

import java.lang.Math;
import java.awt.*;

public class Elemento {

    public int creado;
    public int inicioProceso;
    public int tiempoProceso;

    public Elemento(int tiempo) {
        creado = tiempo + (int)(Math.random() * 10);
    }

    public void Dibujar(Graphics g) {

        g.setColor(Color.black);

        g.drawRect(
            creado * 5,
            100,
            2,
            2
        );

        g.drawLine(
            creado * 5,
            100,
            inicioProceso * 5,
            150
        );

        g.drawRect(
            inicioProceso * 5,
            150,
            tiempoProceso * 5,
            2
        );
    }
}

¿Qué representa el gráfico?

El método Dibujar permite visualizar las diferentes etapas por las que pasa cada elemento.

• Un pequeño rectángulo representa el momento en el que el elemento llega a la cola.
• Una línea inclinada representa el tiempo durante el cual permanece esperando.
• Un rectángulo horizontal representa el tiempo durante el cual el elemento está siendo procesado.

2. Clase Cola

A continuación se define la clase Cola, heredándola de la clase Vector.

Esta clase incorpora tres operaciones principales:

• anadirElemento: añade un nuevo elemento a la cola.
• tieneElementos: comprueba si todavía existen elementos pendientes.
• procesarElemento: procesa el primer elemento de la cola, lo elimina y lo almacena en el vector de elementos procesados.

Cola.java JAVA

import java.util.*;

public class Cola extends Vector {

    public int anadirElemento(int tiempo) {

        Elemento elem;

        elem = new Elemento(tiempo);

        this.addElement(elem);

        return elem.creado;
    }

    public boolean tieneElementos() {

        Enumeration enumeracion = this.elements();

        return enumeracion.hasMoreElements();
    }

    public Elemento procesarElemento(Vector colaProcesados) {

        Elemento elem =
            (Elemento)this.elementAt(0);

        elem.tiempoProceso =
            (int)(Math.random() * 10);

        colaProcesados.addElement(elem);

        this.removeElementAt(0);

        return elem;
    }
}

Métodos utilizados de Vector

En la función anadirElemento se utiliza addElement(), perteneciente a Vector, para introducir un nuevo objeto.

En tieneElementos se utiliza Enumeration para recorrer o consultar los elementos contenidos en el vector.

Finalmente, en procesarElemento aparecen tres operaciones importantes:

Método	Función
addElement()	Añade un elemento al Vector.
elementAt()	Obtiene el elemento situado en una posición determinada.
removeElementAt()	Elimina el elemento situado en una posición determinada.

3. Clase DrawWindow

La clase DrawWindow se encarga de realizar la representación gráfica de los elementos que han sido procesados.

Esta clase hereda de Panel e implementa el método paint, que recibe como argumento un objeto de tipo Graphics.

Para recorrer el vector de elementos procesados se utiliza nuevamente un objeto de tipo Enumeration.

DrawWindow.java JAVA

import java.awt.*;
import java.util.Vector;
import java.util.Enumeration;

public class DrawWindow extends Panel {

    private Vector v;

    public DrawWindow(Vector v) {

        super(new FlowLayout());

        this.v = v;
    }

    public void paint(Graphics g) {

        Elemento dib;
        Enumeration e;

        e = v.elements();

        while (e.hasMoreElements()) {

            dib = (Elemento)e.nextElement();

            dib.Dibujar(g);
        }
    }
}

4. Clase principal ColaSimple

La clase ColaSimple contiene las variables que controlan el tiempo de la simulación y el método principal main().

Dentro de este método se crea un objeto de tipo Cola y un objeto Vector denominado colaProcesada.

También se crean los objetos gráficos Frame y DrawWindow, que permitirán visualizar posteriormente los resultados de la simulación.

Nota sobre el código original El fragmento original de esta clase contiene algunas condiciones incompletas en los bucles while. La estructura que aparece a continuación reconstruye la lógica general de la simulación para facilitar su lectura y estudio.

ColaSimple.java JAVA

import java.lang.Math;
import java.awt.*;
import java.util.*;

public class ColaSimple {

    private static int tiempo;
    private static int horaLibre;

    public static void main(String args[]) {

        System.out.println(
            "Inicio de Simulación de Cola simple"
        );

        Cola cola = new Cola();

        Vector colaProcesada = new Vector();

        Frame ventana =
            new Frame("Simulación de cola simple");

        DrawWindow mipanel =
            new DrawWindow(colaProcesada);

        ventana.add(mipanel);

        ventana.pack();

        ventana.setSize(500, 500);


        while (tiempo < 100) {

            tiempo =
                cola.anadirElemento(tiempo);

            System.out.println(
                "Tiempo: " + tiempo +
                " Items: " + cola.size()
            );


            while (
                (horaLibre <= tiempo) &&
                cola.tieneElementos()
            ) {

                Elemento procesado =
                    cola.procesarElemento(
                        colaProcesada
                    );

                procesado.inicioProceso =
                    Math.max(
                        horaLibre,
                        procesado.creado
                    );

                horaLibre =
                    procesado.inicioProceso +
                    procesado.tiempoProceso;

                System.out.println(
                    "Tiempo: " + tiempo +
                    " Items: " + cola.size() +
                    " Hora entrada: " +
                    procesado.creado +
                    " Tiempo proceso: " +
                    procesado.tiempoProceso
                );
            }
        }

        ventana.show();
    }
}

5. Estructura del programa

Podemos resumir las responsabilidades de cada clase de la siguiente manera:

Clase	Responsabilidad
Elemento	Representa cada elemento que llega al sistema y almacena sus tiempos.
Cola	Administra los elementos pendientes y su procesamiento.
DrawWindow	Representa gráficamente los elementos procesados.
ColaSimple	Controla la simulación y contiene el método main().

6. Ejercicio propuesto

Práctica Lee detenidamente el código e identifica las clases, objetos, interfaces, variables miembro, funciones miembro y relaciones de herencia presentes en el programa.

1. Compilar y ejecutar el programa

Compila las diferentes clases Java y observa el comportamiento de la simulación y su salida gráfica.

Terminal SHELL

javac Elemento.java
javac Cola.java
javac DrawWindow.java
javac ColaSimple.java

java ColaSimple

2. Introducir parámetros de configuración

Modifica la aplicación para que sea posible proporcionar cuatro valores desde la línea de comandos. Estos valores definirán los rangos de las distribuciones uniformes utilizadas para los tiempos de llegada y procesamiento.

La ejecución deberá seguir la siguiente estructura:

Terminal SHELL

java ColaSimple t1 t2 t3 t4

t1: tiempo mínimo entre llegadas.

t2: tiempo máximo entre llegadas.

t3: tiempo mínimo de proceso.

t4: tiempo máximo de proceso.

Si no se proporcionan exactamente los cuatro argumentos, el programa deberá mostrar un mensaje indicando que es necesario introducir los parámetros correspondientes.

3. Procesar todos los elementos pendientes

Actualmente la generación de nuevos elementos finaliza cuando el tiempo de simulación alcanza las 100 unidades.

Modifica el programa para que, una vez alcanzado ese instante, no se generen nuevos elementos, pero continúe procesando todos aquellos que permanezcan en la cola.

Resultado esperado La simulación únicamente debe finalizar cuando no existan más elementos pendientes de procesamiento.

4. Mejorar la representación gráfica

Modifica el código para añadir una segunda representación gráfica en la que cada elemento procesado ocupe una fila.

En cada fila deberán diferenciarse visualmente dos períodos:

• Tramo azul: tiempo durante el cual el elemento permanece esperando en la cola.
• Tramo rojo: tiempo durante el cual el elemento está siendo atendido.

Ejemplo conceptual

Elemento 1

Elemento 2

Elemento 3

Espera Servicio

5. Diseñar una nueva salida gráfica

Finalmente, piensa y desarrolla una representación gráfica diferente que permita comprender de forma intuitiva el comportamiento del sistema.

Algunas posibilidades podrían ser representar la longitud de la cola a lo largo del tiempo, mostrar el número de elementos atendidos o representar visualmente los períodos durante los cuales el servidor permanece ocupado o libre.

7. Conceptos de Java utilizados

Este ejercicio permite trabajar simultáneamente con diferentes conceptos fundamentales de Java:

• Programación Orientada a Objetos.
• Clases y objetos.
• Constructores.
• Variables y métodos miembro.
• Herencia.
• Colecciones mediante Vector.
• Recorrido mediante Enumeration.
• Generación de números pseudoaleatorios.
• Representación gráfica mediante AWT.
• Uso de Graphics.
• Procesamiento de argumentos desde la línea de comandos.

Compatibilidad con Java moderno Este ejercicio utiliza algunas clases y técnicas habituales en programas Java antiguos, como Vector, Enumeration, AWT y Frame.show().

Para estudiar el código original son perfectamente válidas, aunque en aplicaciones Java modernas normalmente se utilizan colecciones genéricas, interfaces como Queue, estructuras como ArrayList o ArrayDeque y alternativas gráficas más actuales.

Conclusión

La simulación de una cola simple es un excelente ejercicio para comprender cómo diferentes objetos pueden interactuar dentro de un programa Java. Cada elemento dispone de un instante de llegada, un período de espera y un tiempo de procesamiento, mientras que la clase encargada de la cola administra el orden en el que dichos elementos son atendidos.

Además de reforzar los conceptos fundamentales de Programación Orientada a Objetos, el ejercicio permite introducir conceptos propios de la simulación de sistemas discretos, como tiempos de llegada, tiempos de servicio, espera, utilización del recurso y acumulación de elementos en una cola.

Las modificaciones propuestas permiten ampliar progresivamente el programa hasta convertirlo en una simulación configurable y con una representación gráfica mucho más útil para analizar el comportamiento del sistema.