El problema trata sobre cinco filsofos que se sientan alrededor de una mesa redonda, al lado

de ellos hay un tenedor, siendo un total de cinco tenedores. Cuando un filsofo quiere comer,
debe utilizar dos tenedores, y cuando no es posible tomar los dos tenedores, el filsofo debe
esperar a que los filsofos de los lados dejen de utilizar los tenedores. El estado de un filsofo
puede ser pensativo, comiendo y hambriento. Cuando un filsofo esta hambriento se le debe
dar prioridad para que pueda utilizar los tenedores y comer. Se busca un mecanismo que sea
sincronizado, cumpla con los requisitos habituales de progreso, no tenga deadlocks, y que sea
de espera limitada y equitativa.
Monitor
Datos:
condition puede_comer[NUM_FILOSOFOS];
enum estados {PENSANDO,HAMBRIENTO,COMIENDO} estado[NUM_FILOSOFOS-1];
int ndice;
INICIALIZACIN:
for (indice=0; indice<NUM_FILOSOFOS; indice++){
estado[indice] = PENSANDO;
}
PROCEDIMIENTOS DEL MONITOR:
/* se piden los tenedores para comer */
entry void tomar_tenedores(int num) {

/*Anunciar que esta hambriento */
estado[num] = HAMBRIENTO;

/* si los vecinos no estn comiendo, proceder */
if ((estado[num-1 mod NUM_FILOSOFOS] != COMIENDO) &&
(estado[num+1 mod NUM_FILOSOFOS] != COMIENDO)){
estado[num] = COMIENDO;
}
/* de otra manera, esperar */
else{
puede_comer[num].wait;

/* listo para comer */
estado[num] = COMIENDO;
}
}











/* anunciar que ha dejado de comer, para darle oportunidad a
los demas */
entry void dejar_tenedores(int num) {

/*anunciar que dej de comer, se cambia el estado*/
estado[num] = PENSANDO;

/* le da la chance de comer al vecino izquierdo */
if ((estado [num-1 mod NUM_FILOSOFOS] == HAMBRIENTO) &&
(estado[num-2 mod NUM_FILOSOFOS] != COMIENDO)) {
puede_comer[num-1 mod NUM_FILOSOFOS].signal;
}

/* le da chance de comer al vecino derecho */
if ((estado [num+1 mod NUM_FILOSOFOS] == HAMBRIENTO) &&
(estado [num+2 mod NUM_FILOSOFOS] != COMIENDO)) {
puede_comer[num+1 mod NUM_FILOSOFOS].signal;
}
}

Filsofo
/* buscar el id, y luego repetir por siempre */
int yo = obtener_id();
while (TRUE) {
/* pensar, esperar, comer, hacerlo una y otra vez */
pensar();
tomar_tenedores(yo);
comer();
dejar_tenedores(yo);
}













Nosotros hablaremos sobre la cena de los filsofos
El problema consiste en 5 filsofos, sentados alrededor de una mesa redonda y un plato de
fideos en el centro, cada filsofo tiene a su izquierda un tenedor, en total son 5 tenedores.
Un filsofo puede tener 3 estados distintos
Pensando: que es el estado inicial
Comiendo: cuando est usando los dos tenedores
Y Hambriento: cuando esta hambriento se le da la prioridad para que pueda utilizar los
tenedores y comer.
Cuando un filsofo quiere comer debe levantar los 2 tenedores a sus extremos, si algn
tenedor a su izquierda o su derecha est ocupado debe esperar, con el tenedor que agarro en
la mano.
Se produce un deadlock cuando los 5 filsofos toman 1 tenedor al mismo tiempo, entonces
todos se esperan entre si y nunca dejan los tenedores
Entonces para solucionar esto se crea un monitor que pueda ver que el tiempo de espera de
cada filsofo sea limitado y equitativo.
Entonces aqu se define una variable que indica cuando puede comer el filsofo
Aqu estn los 3 estados distintos que pueden tomar
Y el ndice es para recorrer e inicializar el estado de los filsofos en PENSANDO
Mi compaera hablara sobre el procedimiento de tomar los tenedores