CENA DE FILSOFOS

Hay cinco filsofos chinos que se pasan sus vidas

pensando y comiendo. Comparten una mesa circular,
alrededor de la cual se sientan. En su centro se encuentra
con una provisin infinita de arroz, y sobre ella hay cinco
palitos, uno de cada lado de los filsofos. Cuando un
filsofo piensa, no interacta con sus colegas

CHIRINO ALVARADO CARLA RUBI.

GOMEZ LOPEZ ERICK RAUL.
VAZQUEZ ALVAREZ ELENA IVETTE.
VILLATORO CONSTANTINO LUIS EDUARDO.
 INTRODUCCIN.

El problema de los filsofos cenando es un problema clsico de las ciencias de la

computacin propuesto por Edsger Dijkstra en 1965 para representar el problema de la
sincronizacin de procesos en un sistema operativo. Cabe aclarar que la interpretacin est
basada en pensadores chinos, quienes coman con dos palillos, donde es ms lgico que se
necesite el del comensal que se siente al lado para poder comer.
 PLANTEAMIENTO DEL PROBLEMA.

Cinco filsofos se sientan alrededor de una mesa y pasan su vida cenando y pensando. Cada
filsofo tiene un plato de fideos y un tenedor a la izquierda de su plato. Para comer los fideos son
necesarios dos tenedores y cada filsofo slo puede tomar los que estn a su izquierda y derecha.
Si cualquier filsofo toma un tenedor y el otro est ocupado, se quedar esperando, con el
tenedor en la mano, hasta que pueda tomar el otro tenedor, para luego empezar a comer.

Si dos filsofos adyacentes intentan tomar el mismo tenedor a una vez, se produce una condicin
de carrera: ambos compiten por tomar el mismo tenedor, y uno de ellos se queda sin comer.

Si todos los filsofos toman el tenedor que est a su derecha al mismo tiempo, entonces todos se
quedarn esperando eternamente, porque alguien debe liberar el tenedor que les falta. Nadie lo
har porque todos se encuentran en la misma situacin (esperando que alguno deje sus
tenedores). Entonces los filsofos se morirn de hambre. Este bloqueo mutuo se denomina
interbloqueo deadlock, que no es ms que el bloqueo permanente de un grupo de procesos. El
problema consiste en encontrar un algoritmo que permita que los filsofos nunca se mueran de
hambre.
ALGORITMO CENA DE FILSOFOS
 SOLUCIN PROPUESTA EN JAVA

package sistoper;

public class cena3 implements Runnable

{

private int n;
private cenando cenar;

public cena3(int i, cenando dr)

{
n=i;
cenar=dr;
}
public void pensar()
{
System.out.println(n+"pensando..");
try
{
Thread.sleep(100+(int)(Math.random()*1000.0));
}
catch (Exception e)
{

}
}
public void run()
{
int x=2;
for (int t=0; t<x; t++)
{
pensar();
cenar.cena(n);
x++;
}
}

}
class cenando
{

int pensando=0;
int hambriento=1;
int comiendo=2;
 private int[] estado = {
pensando,pensando,pensando,pensando,pensando};

private void comer(int d)

{
System.out.println(d+"Comiendo");
try
{
Thread.sleep(50+(int)(Math.random()*800.0));
}
catch (Exception e)
{

}
}
public void cena(int a)
{
tomar(a);
comer(a);
soltar(a);
}
private synchronized void tomar(int b)
{
estado[b]=hambriento;
System.out.println(b+"hambriento");
probar(b);
while ( estado[b] != comiendo )
try
{
wait();
}
catch(Exception e)
{

}
}
private synchronized void soltar(int i)
{
estado[i]=pensando;
probar((i+4)%5);
probar((i+1)%5);
}
private void probar(int p)
{
if ( estado[p] == hambriento && estado[(p+1)%5] !=
comiendo&& estado[(p+4)%5] != comiendo)
{
estado[p]=comiendo;
notifyAll();
}
}
 public static void main(String args[])
{
cenando dr=new cenando();
cena3 p[]={ new cena3(0,dr),new cena3(1,dr), new
cena3(2,dr),new cena3(3,dr), new cena3(4,dr) };
for (int i=0; i<p.length; i++)
{
new Thread(p[i]).start();

}
}