Hago que ande bien.

El otro no andaba. Ahora cambia la logica, en lugar de agarrar de a un palito, espera a tener
ambos palitos libres antes de comenzar pasar el lock. De esperar a 1 a la vez, se daba la posibilidad
de bloqueo.

diff --git a/src/filosofos3.java b/src/filosofos3.java
index 68299de4249c2c6ff71f44d56c2a0348184e3855..ca8b595c502161dfe7090fbe82801ee9a62ba7b6 100644 (file)
--- a/src/filosofos3.java
+++ b/src/filosofos3.java
@@ -2,43 +2,51 @@
 import java.util.Random;
 
 class Palitos 
-       //extends Monitor
 {
        /* Infica si un palito esta ocupado */
        private boolean[] palitos;
-//     private Variable[] cond_palitos;
+       private int size;
 
        Palitos (int n)
        {
+               size = n;
                palitos = new boolean[n];
-               //cond_palitos = new ConditionVariable[n];
        }
 
-       public synchronized boolean obtenerPalito (int i)
+       public synchronized boolean obtenerPalitos (int caller, int izq, int der)
        {
-               /* Espero a que el palito "i" sea liberado */
-               while (palitos[i]) {
+               /* Espero mientras algun palito este ocupado */
+               while (palitos[izq] || palitos[der]) {
                        try {
-                               wait () ; //cond_palitos[i]);
+                               wait ();
                        }
                        catch (Exception e) {}
-                       finally { }
                }
        
-               palitos[i] = true;
+               String s = (new Integer (caller)).toString ();
+               System.out.println ("Soy "+s+" y agarro mis palitos");
+               palitos[der] = true;
+               palitos[izq] = true;
 
                return true;
        }
 
-       public synchronized boolean soltarPalito (int i)
+       public int Size ()
        {
-               palitos[i] = false;
+               return size;
+       }
+
+       public synchronized boolean soltarPalitos (int caller, int izq, int der)
+       {
+               String s = (new Integer (caller)).toString ();
+               System.out.println ("Soy "+s+" y suelto mis palitos");
+               palitos[izq] = false;
+               palitos[der] = false;
 
                /* Despierto 1 thread que este esperando por este
                 * palito
                 */
                notify ();
-               //cond_palitos[i]);
                return true;
        }
 }
@@ -46,6 +54,7 @@ class Palitos
 class Filosofo extends Thread
 {
        private String id;
+       private int iId;
        private int comidas;
        private int comidas_actuales;
        private int izq;
@@ -53,9 +62,10 @@ class Filosofo extends Thread
        private Palitos palitos;
        private Random r = new Random ();
 
-       Filosofo (String _id, int cant_comidas, int _izq, int _der, Palitos p)
+       Filosofo (int _id, int cant_comidas, int _izq, int _der, Palitos p)
        {
-               id = _id;
+               iId = _id;
+               id = (new Integer (_id)).toString ();
                comidas = cant_comidas;
                comidas_actuales = 0;
                izq = _izq;
@@ -66,9 +76,10 @@ class Filosofo extends Thread
        public void run ()
        {
                while (comidas_actuales < comidas) {
+                       if (comidas_actuales%100 == 0) {
+                               System.out.println ("Comida " + (new Integer (comidas_actuales)).toString());
+                       }
                        pensar ();
-                       agarrarPaloIzquierdo ();
-                       agarrarPaloDerecho ();
                        comer ();
                }
                System.out.println ("Listo el pollo "+id);
@@ -77,39 +88,27 @@ class Filosofo extends Thread
        public void comer ()
        {
                int n = r.nextInt (5) + r.nextInt (2);
+               palitos.obtenerPalitos (iId, izq, der);
                System.out.println ("Soy " + id + " y estoy comiendo por " + (new Integer(n)).toString ());
                comidas_actuales++;
+               n = 0;
                try {
                        Thread.sleep (n*1000);
                } catch (Exception e) {}
-               finally {}
+
+               palitos.soltarPalitos (iId, izq, der);
        }
 
        public void pensar ()
        {
                int n = r.nextInt (5) + r.nextInt (2);
                System.out.println ("Soy " + id + " y estoy pensando por " + (new Integer(n)).toString ());
+               n = 0;
                try {
                        Thread.sleep (n*1000);
                } catch (Exception e) {}
                finally {}
        }
-
-       public void agarrarPaloIzquierdo ()
-       {
-               if (palitos.obtenerPalito (izq))
-                       System.out.println ("Soy " + id + " y estoy agarrando el palizo izquierdo.");
-               else
-                       System.out.println ("IZQ-ERROR?? : Creo que no deberia llegar aca.");
-       }
-
-       public void agarrarPaloDerecho ()
-       {
-               if (palitos.soltarPalito (der))
-                       System.out.println ("Soy " + id + " y estoy agarrando el palizo derecho.");
-               else
-                       System.out.println ("DER-ERROR?? : Creo que no deberia llegar aca.");
-       }
 }
 
 public class filosofos3
@@ -135,8 +134,7 @@ public class filosofos3
 
                Palitos p = new Palitos (n);
                for (i=0; i<n; i++) {
-                       String s = (new Integer(i)).toString ();
-                       Filosofo f = new Filosofo (s, cant, i, (i+1)%n, p);
+                       Filosofo f = new Filosofo (i, cant, i, (i+1)%n, p);
                        f.start ();
                }
        }