Práctica 09

Noviembre 2017

/* Los cinco filósofos comensales */

Cinco filósofos gastan sus vidas en pensar y com er. Los filósofos com parten
una m esa redonda con cinco sillas, una para cada filósofo. En el centro de la
m esa hay una fuente de arroz y la m esa se ha puesto solo con cinco tenedores.
Cuando un filósofo piensa, no se relaciona con sus colegas. De vez en cuando,
un filósofo tiene ham bre y trata de tom ar los tenedores m as próxim os a él ( los
tenedores que se encuentran entre él y sus vecinos de la izquierda y la
derecha) Un filósofo solo puede coger un tenedor cada vez. Obviam ente, no
puede coger un tenedor que ya haya tom ado un vecino de m esa. Cuando un
filósofo ham briento ha conseguido los dos tenedores, com e sin soltarlos,
cuando term ina de com er, los coloca de nuevo sobre la m esa y vuelve a pensar.

El problem a de la cena de los filósofos se considera un problem a clásico de

sincronización, porque es un ejem plo de una am plia clase de problem as de
control de concurrencia. Es una representación sencilla de la necesidad de
repartir varios recursos entre varios procesos de una form a que no se
produzcan interbloqueos, ni bloqueos indefinidos.
Usando las llam adas al sistem a señaladas a continuación, verifique si se
resuelve de form a justa el problem a de los cinco filósofos.

sem_t mutex ;
sem_init (&mutex, 0, 1);
sem_wait(&mutex);
sem_post(&mutex);

Conceptos que debe cum plir el program a:

Exclusión mutua:
Solo un proceso puede estar en la sección crítica a la vez.

Progreso:
N ingún proceso debe forzarse a esperar por un recurso disponible.

Espera acotada:
N ingún proceso puede esperar indefinidam ente un recurso.

Com pile y ejecute el program a por al m enos 1000 ciclos contabilizando la

cantidad de veces que cada uno de los filósofos com e y piensa, reporte
cuantas veces com ieron y pensaron cada uno de los filósofos.

Entregue el código del program a y el núm ero de veces que cada uno de los
filósofos ha com ido adem ás de sus com entarios sobre el resultado
anterior.
 Práctica 09
Noviembre 2017
//http://pageegap.blogspot.mx/2008/03/el-problema-de-los-filsofos.html

/*
Solución al problema de los 5 filósofos
*/

#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>

#define N 5 //num. de filosofos

#define IZQ (i-1)%N //vecino izquierdo de i
#define DER (i+1)%N //vecino derecho de i
#define PENSANDO 0
#define CON_HAMBRE 1
#define COME 2

pthread_t filos[N]; //hilos que representan a los filósofos

sem_t mutex ; //semáforo para la sección crítica
sem_t s[N]; //semáforos para los filósofos
int estado [N] ; //estado actual de cada filósosfo

/*
el filosofo i va a perder el tiempo... (va a pensar)
*/

void pensar (int i)

{
int t ;
t = rand() % 11;
printf("Filosofo %d pensando... \n", i) ;
estado[i] = PENSANDO;
sleep (t) ;
}

/*
El filosofo i, va a comer !!!!!!!!
*/

void comer (int i)

{
printf("Filósofo %d esta comiendo.\n", i);
estado[i] = COME;
sleep (7);
}

/*
Verifica que pueda tomar ambos tenedores
*/

void verifica(int i)
{
if( estado[i]==CON_HAMBRE && estado[IZQ]!=COME && estado[DER]!=COME ){
estado[i] = COME;
 Práctica 09
Noviembre 2017
printf("Filósofo %d comiendo...\n", i) ;
sem_post(&s[i]);
}
}

/*
El filosofo i intenta tomar los tenedores
*/

void toma_tndrs(int i)
{

sem_wait(&mutex); //entra a la sección crítica, hace uso del semaforo

estado[i] = CON_HAMBRE; //dice: tengo mucha hambre!!!!!!!!!!
verifica(i); // verifica que pueda tomar los tenedores
sem_post(&mutex); //sale de la sección crítica y el sem. puede
permitir la entrada a alguien más
sem_wait(&s[i]); //se bloquea si no consiguió los tenedores
}

/*
el filosofo i dejará los tenedores
*/

void deja_tndrs(int i)
{

sem_wait(&mutex); // de nuevo entra a la sección critica

estado[i] = PENSANDO; //deja de comer y se pone a pensar
verifica(IZQ);
verifica(DER);
sem_post(&mutex);
}

/*
filosofos

*/
void * filosofos (int i)
{
int j ;

for (; ; )
{
pensar(i) ;
toma_tndrs(i) ;
comer(i) ;
deja_tndrs(i) ;
}
}
 Práctica 09
Noviembre 2017
main()
{
int i ;
for(i = 0; i < 5; i++){
sem_init (&s[i], 0, 1);
estado[i] = PENSANDO ;
}

sem_init (&mutex, 0, 1);

//creamos un hilo de ejecucion para cada filosofo, que ejecuta filósofos()

for (i=0; i<N; i++)
pthread_create(&filos[i], NULL, (void *)filosofos,(void *) i);

//cada hilo espera a que terminen los demás y libera los recursos
for (i=0; i<N; i++){
pthread_join(filos[i],NULL);
}