Documentación para todas las clases y métodos

src/sis/infracomp/threads/Comensal.java

@@ -9,6 +9,7 @@ public class Comensal extends Thread{
     private boolean cubiertoT1;         // Si es true, entonces tiene un cubierto de tipo T1, false de lo contrario
     private boolean cubiertoT2;         // Si es true, entonces tiene un cubierto de tipo T2, false de lo contrario
     private int tipoCubiertoBuscado;    // El tipo de cubierto que está busscando en esta iteración (1 o 2)
+
     private Fregadero fregadero;
     private Mesa mesa;
     private Random r = new Random();
@@ -21,35 +22,58 @@ public Comensal(int numPlatos, Fregadero fregadero, Mesa mesa){
 
         this.cubiertoT1 = false;
         this.cubiertoT2 = false;
-        this.tipoCubiertoBuscado = 0; 
+        this.tipoCubiertoBuscado = 0;
 
     }
 
     public void run(){
-        mesa.comenzarComer();             
+        // Comienza a comer, es decir, aumenta el contador de comensales comiendo
+        mesa.comenzarComer();
+
+        // Ejecuta un loop para comer desde el primer plato hasta el plato de la mitad
         while (numPlatosActual < numPlatosMitad){  
             comer();
         }
+
+        // Una vez termina de comer, decrementa el contador de comensales comiendo
         mesa.terminarComer();
+
+        // Si este comensal es el último entonces pide a la mesa notificar al resto que ha acabado para continuar con la cena
         if (mesa.getComensalesComiento() == 0){
             mesa.continuarComiendo();
         }
+
+        // Si no ha terminado, dice que esperará a que el resto de comensales terminen la mitad de la cena y espera en la mesa
         else{
             mesa.decirAlgo(Thread.currentThread().getId()+": Esperando a que el resto de los comensales lleguen a "+numPlatosMitad);
             mesa.esperarComensales();
         }
+
+        // Una vez todos se despiertan ejecutan comenzarComer para aumentar el contador de comensales comiendo en la mesa
         mesa.comenzarComer();
+
+        // Una vez más se ejecuta el while pero esta vez para terminar de comer el numero de platos completo (puesto que numPlatosActual ya tiene el valor intermedio)
         while (numPlatosActual < numPlatos){
             comer();
         }
+
+        // Cuando termina de comer, ejecuta terminarComer para decrementar el contador de comensales comiendo y dice que está lleno
         mesa.terminarComer();
         mesa.decirAlgo(Thread.currentThread().getId()+": Estoy lleno");
+
+        // Si es el último comensal en terminar el último plato, entonces dice que fue el último en comer y se va a mimir, terminando así la ejecución del programa
         if (mesa.getComensalesComiento() == 0){
             mesa.decirAlgo(Thread.currentThread().getId()+": Fui el último en terminar de comer, a mimir");
             System.exit(0);
         }
     }
 
+
+    /**
+     * Este método verifica qué cubierto se está buscando y actualiza los cubiertos que ya se tienen
+     * 
+     * @param cubierto el cubierto que se ha agarraado en esta iteración
+     */
     private void verificarCubierto(int cubierto){
         if (cubierto == 1){
             this.cubiertoT1 = true;
@@ -60,43 +84,68 @@ private void verificarCubierto(int cubierto){
         }
     }
 
+    /**
+     * El método comer es el plato principal de este programa, pues utiliza condiciones aprovechando
+     * que cubiertoT1 y cubiertoT2 son booleanos
+     */
     private void comer(){
+        // En primera instancia se verifica si se posee un cubiertoT1 y un cubiertoT2 para comer el plato 
         if (cubiertoT1 && cubiertoT2){
-            try{sleep((long) r.nextInt(3)+3);}catch(Exception e){e.printStackTrace();}
-            numPlatosActual += 1;
+
+            // Si es así, el comensal come el plato (espera entre 3 y 5 segundos) y aumenta el número de platos que ha comido
             mesa.decirAlgo(Thread.currentThread().getId()+": Voy a comer. Me faltan "+(numPlatos-numPlatosActual)+" platos");
-            try{sleep((long) r.nextInt(3)+3);}catch(Exception e){e.printStackTrace();}
+            try{sleep((long) (r.nextInt(3)+3)*1000);}catch(Exception e){e.printStackTrace();}
+            numPlatosActual += 1;
 
+            // Una vez terminado el plato, se libera de sus cubiertos y busca meterlos en el fregadero, por ello se deshace primero del cubiertoT1
             this.cubiertoT1 = false;
 
+            // Mientras no pueda meterlo en el fregadero espera en modo semi-activo con yield, una vez pueda ejecuta el método agregar del fregadero
             while(!fregadero.sePuedeMeter()){
                 Thread.yield();
             }
             fregadero.agregar(1);
+
+            // Luego realiza el mismo procedimiento con el cubiertoT2
             this.cubiertoT2 = false;
             while(!fregadero.sePuedeMeter()){
                 Thread.yield();
             }
             fregadero.agregar(2);
 
+            // Finalmente se deshace del tipo de cubierto que busca, de modo que pueda agarrar cualquiera
             tipoCubiertoBuscado = 0;
+
+            // Finalmente espera de 1 a 3 segundos por el siguiente plato
+            try{sleep((long) (r.nextInt(3)+1)*1000);}catch(Exception e){e.printStackTrace();}
         }
+
+        // Si no puede comer entonces realiza las siguientes instrucciones
         else{
 
+            // Agarra un cubierto de la msea
             int cubierto = mesa.retirar();
+
+            // Verifica si no busca un cubierto en especial (caso en el que haya terminado de comer un plato) y actualiza los datos de sus cubiertos
             if (tipoCubiertoBuscado == 0){
                 verificarCubierto(cubierto);
             }
+
+            // Si el cubierto que agarró corresponde con el buscado, entonces actualiza los datos de sus dos cubiertos
             else if (cubierto == tipoCubiertoBuscado){
                 verificarCubierto(cubierto);
             }
+
+            // Si el cubierto que agarró no corresponde con el que busca entonces deja los dos en la mesa y se deshace de ellos
             else if (cubiertoT1 || cubiertoT2) {
                 mesa.agregar(cubierto);
                 mesa.agregar(cubierto);
 
                 this.cubiertoT1 = false;
                 this.cubiertoT2 = false;
             } 
+
+            // Finalmente, si el cubierto que agarró no corresponde con el que busca entonces lo vuelve a dejar en la mesa
             else{
                 mesa.agregar(cubierto);
             }   

src/sis/infracomp/threads/Fregadero.java

@@ -3,29 +3,49 @@
 import java.util.*;
 
 public class Fregadero {
-    private int tamFregadero;
-    private ArrayList<Object> buff;
+    private int tamFregadero;       // El tamaño máximo del fregadero
+    private ArrayList<Object> buff; // El ArrayList que guarda los cubiertos
 
     public Fregadero(int tamFregadero){
         this.tamFregadero = tamFregadero;
         buff = new ArrayList<Object>();
     }
 
-    public synchronized void agregar(int cubiertos){
-            buff.add(cubiertos);
-            System.out.println("Fregadero: "+buff+" --- Metieron al fregadero un "+cubiertos);
+    /**
+     * Añade un cubierto a la cola buffer, no se verifica si es posible hacerlo dentro de la función ya que esta se hace antes de hacer la inserción
+     * 
+     * @param cubierto el tipo de cubierto insertado (1 para cubiertoT1 y 2 para cubiertoT2)
+     */
+    public synchronized void agregar(int cubierto){
+            buff.add(cubierto);
+            System.out.println("Fregadero: "+buff+" --- Metieron al fregadero un "+cubierto);
     }
 
+    /**
+     * Quita un cubierto del tope del buffer, no se verifica si es posible haerlo dentro de la función ya que esta se hace antes de hacer la eliminación
+     * 
+     * @return el tipo de cubierto que se retiró (1 para cubiertoT1 y 2 para cubiertoT2)
+     */
     public synchronized int retirar(){
             Integer i = (Integer) buff.remove(0);
             System.out.println("Fregadero: "+buff+" --- Lavaplatos está lavando "+i);
             return i;
     }
 
+    /**
+     * Un método sincronizado que verifica si es posible ingresar un cubierto al fregadero
+     * 
+     * @return true si hay espacio en el fregadero, falso si está lleno
+     */
     public synchronized boolean sePuedeMeter(){
         return buff.size() < tamFregadero;
     }
 
+    /**
+     *  Un método sincronizado que verifica si es posible retirar un cubierto del fregadero
+     * 
+     * @return true si hay cubiertos en el fregadero, false de lo contrario
+     */
     public synchronized boolean sePuedeRetirar(){
         return buff.size() > 0;
     }

src/sis/infracomp/threads/Lavaplatos.java

@@ -13,15 +13,25 @@ public Lavaplatos (Fregadero fregadero, Mesa mesa){
     }
 
     public void run(){
+        // Ejecuta un ciclo infinito para lavar los platos
         while (true){
+
+            // Verifica si es posible retirar un cubierto del fregadero para lavarlo
             while(!fregadero.sePuedeRetirar()){
+
+                // Si no hay cubiertos aún espera de manera semi-activa con un yield
                 Thread.yield();
             }
+
+            // Cuando tenga la posibilidad de retirar el cubierto ejecuta la función retirar de manera sincronizada
             int cubierto = fregadero.retirar();
+
+            // Luego procede a lavar el cubierto con la instrucción sleep
             try{
-                sleep((long) r.nextInt(2)+1);
-                // sleep(1);
+                sleep((long) (r.nextInt(2)+1)*1000);
             }catch(Exception e){e.printStackTrace();}
+
+            // Finalmente, agrega el cubierto a la mesa
             mesa.agregar(cubierto);
         }
     }

src/sis/infracomp/threads/Main.java

@@ -22,11 +22,17 @@ public class Main {
 
     public static void main(String[] args) {
 
+        // Información Importante
         System.out.println("El resultado está en un archivo llamado \"solucion.txt\" en el directorio raíz del proyecto");
         System.out.println("Para modificar las propiedades debe modificarse el archivo");
 
+        // Creación del objeto Main que maneja todo el programa
         Main main = new Main();
+
+        // Carga las propiedades del archivo main.properties
         main.loadProperties();
+
+        // Estas instrucciones se encargan de modificar el out del sistema para permitir escribirlo en un archivo y que sea de más fácil acceso que la consola
         try{
             PrintStream fileOut = new PrintStream("./solucion.txt");
             System.setOut(fileOut);
@@ -35,22 +41,33 @@ public static void main(String[] args) {
             e.printStackTrace();
         }
 
+        // AQUÍ INICIA EL PROGRAMA REQUERIDO
+
+        // Se crean objetos de tipo Fregadero, Mesa y Lavaplatos
         Fregadero fregadero = new Fregadero(main.tamFregadero);
         Mesa mesa = new Mesa();
         Lavaplatos lavaplatos = new Lavaplatos(fregadero, mesa);
 
+        // Luego se agregan los cubiertos de tipo 1
         for (int i = 0; i<main.numCubiertosT1; i++)
             mesa.agregar(1);   
 
+        // Y posteriormente los cubiertos de tipo 2
         for (int i = 0; i<main.numCubiertosT2; i++)
-            mesa.agregar(2);   
-
+            mesa.agregar(2);
+
+        // Se inicia el loop infinito del lavaplatos
         lavaplatos.start();
+
+        // Se crean e inician cada uno de los threads Comensal
         for (int i = 0; i<main.numComensales; i++){
             new Comensal(main.numPlatos, fregadero, mesa).start();
         }
     }
 
+    /**
+     * Función hecha para cargar en Main las propiedades del archivo. El archivo está en el directorio raíz y se llama "main.properties"
+     */
     public void loadProperties(){
         try (InputStream input = new FileInputStream("main.properties")){
             Properties prop = new Properties();

src/sis/infracomp/threads/Mesa.java

@@ -3,10 +3,9 @@
 import java.util.ArrayList;
 
 public class Mesa {
-    // private int cantidadCubiertos;
-    private ArrayList<Object> buff;
-    private Object monitorEspera = new Object();
-    private int comensalesComiendo;
+    private ArrayList<Object> buff;                 // El ArrayList del buffer
+    private Object monitorEspera = new Object();    // El monitor de espera para añadir o retirar cubiertos
+    private int comensalesComiendo;                 // La cantidad de comensales comiendo en un momento dado
 
     public Mesa(){
         buff = new ArrayList<Object>();