Está en la página 1de 23

Arias Celis, Carla Barrios Ponce, Rafael Carrera Ypez, Italo Concha Zevallos, Jhony Diaz Zea, Marybel

ENUNCIADO 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 coge un tenedor y el otro est ocupado, se quedar esperando, con el tenedor en la mano, hasta que pueda coger el otro tenedor, para luego empezar a comer.

ENUNCIADO DEL PROBLEMA


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 cogen 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 o deadlock.

El problema consiste en encontrar un algoritmo que permita que los filsofos nunca se mueran de hambre.

ENUNCIADO DEL PROBLEMA

CONDICIONES PARA POSIBLES SOLUCIONES


Una solucin ptima se considerar aquella que permita el que l nmero mximo de filsofos pueda alimentarse a la vez, es decir, maximizar la concurrencia (dos a la vez supuestamente para el caso de 5 filsofos). Se debe evitar que se produzca en nuestra solucin: Interbloqueo Inanicin o postergacin indefinida

CONDICIONES PARA POSIBLES SOLUCIONES


Condiciones para que ocurra un deadlock: Exclusin Mutua: los procesos reclaman control exclusivo de los recursos que piden. Retencin y Espera: los procesos mantienen los recursos que ya les han sido asignados mientras esperan por recursos adicionales No Apropiacin: los recursos no pueden ser extrados de los procesos que los tienen hasta su completa utilizacin Espera Circular: existe una cadena circular de procesos en la cual cada uno de ellos mantiene a uno o ms recursos que son requeridos por el siguiente proceso de la cadena.

ALGUNAS POSIBLES SOLUCIONES


Por turno cclico Se empieza por un filsofo, que si quiere puede comer y despus pasa su turno al de la derecha. Cada filsofo solo puede comer en su turno. Problema: si el nmero de filsofos es muy alto, uno puede morir de hambre antes de su turno.

Varios turnos
Se establecen varios turnos. Para hacerlo ms claro supongamos que cada filsofo que puede comer (es su turno) tiene una ficha que despus pasa a la derecha.

ALGUNAS POSIBLES SOLUCIONES


Colas de tenedores Cuando un filsofo quiere comer se pone en la cola de los dos tenedores que necesita. Cuando un tenedor est libre lo toma. Cuando toma los dos tenedores, come y deja libre los tenedores.
Resolucin de conflictos en colas de tenedores Cada vez que un filsofo tiene un tenedor espera un tiempo aleatorio para conseguir el segundo tenedor. Si en ese tiempo no queda libre el segundo tenedor, suelta el que tiene y vuelve a ponerse en cola para sus dos tenedores.

ALGUNAS POSIBLES SOLUCIONES


El portero del comedor Se indica a los filsofos que abandonen la mesa cuando no tengan hambre y que no regresen a ella hasta que vuelvan a estar hambrientos (cada filsofo siempre se sienta en la misma silla).
Solucin del Camarero Una solucin sencilla se logra mediante la introduccin de un camarero en la mesa. Los filsofos deben solicitar su permiso antes de tomar cualquier tenedor. Debido a que el camarero es consciente de cual tenedor est en uso, es capaz de arbitrar y evitar un deadlock.

ALGUNAS POSIBLES SOLUCIONES


Solucin de Jerarqua de Recursos Otra solucin sencilla se logra mediante la asignacin de un orden parcial, o jerarqua, a los recursos (los tenedores, en este caso), y estableciendo la convencin de que todos los recursos se solicitarn en orden, y sern puestos en libertad en orden inverso. En este caso, si cuatro de los cinco filsofos cogen simultneamente sus tenedores con el nmero ms bajo, slo el tenedor con el nmero ms alto seguir sobre la mesa, por lo que el quinto filsofo no ser capaz de coger ningn tenedor. Permitiendo comer a un filosofo que tendra acceso a los dos tenedores.

Solucin del Camarero I


#include <stdlib.h>
#include <stdio.h> #include <unistd.h> #include <pthread.h> //VARIABLES COMPARTIDAS

char tenedores=5;
char plato=0; char pedidos=0; //MUTEX inicializados estaticamente pthread_mutex_t mbandeja= PTHREAD_MUTEX_INITIALIZER; pthread_mutex_t mmostrador= PTHREAD_MUTEX_INITIALIZER; // Variables de condicin pthread_cond_t cbandeja; pthread_cond_t cmostrador;

pthread_cond_t ccamarero;

Solucin del Camarero II


void *llega_filosofo(int nombre) { while(1) { //Agarro plato o salgo pthread_mutex_lock(&mmostrador); if (plato==0) { pthread_cond_signal(&ccamarero); /*problema, pueden entrar los 5 signals de un tiron, pero solo devuelve el camarero un wait, solucion, contar los signals */ pedidos++; //aseguro exclusion mutua a esta variable con el mutex mmostrador printf("Filosofo (%d): CAMAREROO!!\n", nombre); pthread_cond_wait(&cmostrador, &mmostrador); } if (plato>=1) { plato--; printf("Filosofo (%d): COJO PLATO\n", nombre); }

Solucin del Camarero III


else { printf("Filosofo (%d): SI NO QUEDA COMIDA ME VOY\n", nombre); pthread_mutex_unlock(&mmostrador); pthread_cond_signal(&cmostrador); pthread_exit(NULL); } pthread_mutex_unlock(&mmostrador); //Agarro tenedores pthread_mutex_lock(&mbandeja); if(tenedores<2) { pthread_cond_wait(&cbandeja,&mbandeja); }

Solucin del Camarero IV


tenedores=tenedores-2; printf("Filosofo (%d): Cojo 2 tenedores, quedan %d \n", nombre, tenedores); pthread_mutex_unlock(&mbandeja); printf("Filosofo (%d): MHH COMIDA (comiendo)\n", nombre); sleep(2); //Devuelvo tenedores pthread_mutex_lock(&mbandeja); tenedores=tenedores+2; printf("Filosofo (%d): DEJO LOS TENEDORES EN SU SITIO\n", nombre); pthread_cond_signal(&cbandeja); pthread_mutex_unlock(&mbandeja); } }

Solucin del Camarero V


void *llega_camarero(int nombre) { char max_platos=10; int i; while(max_platos>0) { pthread_mutex_lock(&mmostrador); pthread_cond_wait(&ccamarero,&mmostrador); for (i=0; i<pedidos ; i++) { plato++; pthread_cond_signal(&cmostrador); max_platos--; printf("Camarero: PLATITO DE SPAGUETTI PARA EL FILOSOFO\n"); } pedidos=0; pthread_mutex_unlock(&mmostrador); } pthread_mutex_lock(&mmostrador); pthread_cond_wait(&ccamarero,&mmostrador); plato--; printf("Camarero: SE ACABO LA COMIDA!\n"); pthread_mutex_unlock(&mmostrador); pthread_cond_signal(&cmostrador); pthread_exit(NULL); }

Solucin del Camarero VI


int main(int argc, char**argv) { pthread_t filosofo[5]; pthread_t camarero; int i; pthread_cond_init(&cbandeja,NULL); pthread_cond_init(&cmostrador,NULL); pthread_cond_init(&ccamarero,NULL); //Camarero if(pthread_create(&camarero,NULL,(void*)llega_camarero,NULL)!=0) { printf("ERROR:\n Camarero murio\n"); exit(-1); } else { printf("Llega camarero\n"); }

Solucin del Camarero VII


//Filosofos for(i=1;i<=5;i++) { if(pthread_create(&filosofo[i-1],NULL,(void*)llega_filosofo,(void*)i)!=0) { printf("ERROR:\n Platon murio %d\n",i); exit(-1); } else { printf("Llega filosofo (%d)\n",i); } }

Solucin del Camarero VIII


for(i=1;i<=5;i++) { if(pthread_join(filosofo[i-1],NULL)!=0) { printf("ERROR:\n Platon murio %d\n",i); exit(-1); } else { printf("Se va filosofo (%d)\n",i); } } if(pthread_join(camarero,NULL)!=0) { printf("ERROR:\n camarero murio\n"); exit(-1); } else { printf("Se va el camarero \n"); } exit(0); }

Solucin del Camarero IX

Solucin del Camarero X

Solucin del Camarero XI

Conclusiones
El problema de la cena de los filsofos modela procesos que compiten para tener acceso exclusivo a un nmero limitado de recursos. La falta de tenedores disponibles es una analoga al bloqueo de recursos compartidos en programacin real de computadores.

Referencias
http://es.wikipedia.org/wiki/Problema_de_la_cena_de_lo s_fil%C3%B3sofos http://en.wikipedia.org/wiki/Dining_philosophers_problem http://wwwdi.ujaen.es/~lina/TemasSO/CONCURRENCIA /4ProblemasClasicosdeComunicacionentreProcesos.htm