Título: semáforos, memoria compartida Publicado por: javier_cj93 en 19 Noviembre 2015, 17:11 pm En primer lugar es la primera vez que veo este foro, y veo que es de gran ayuda para toda la gente que tiene dudas. Muchas gracias a todos los que respondeis.
Ahora a ver si podéis ayudarme, gracias a todos. Bien, el ejercicio trata de hacer una variante del productor consumidor, (en mi caso dos productores, 1º piezas_roja y 2º piezas_azul) con un único consumidor. Pues bien para proteger la variable numero de piezas utilizo un mutex. Para ver el estado de los buffer, tengo definidos 2 semaforos por productor, uno inicalizado a 0 ( el que me dice el número de piezas que tiene el buffer ) y el de vacio inicializado a 50 haciendo referencia a los huecos que tiene el buffer. Bien el programa me funciona, lo que pasa es que me sigue poniendo piezas cuando llega a 50.. y no entiendo porque. Si alguien me ayuda y me dice donde está el fallo. Un saludo! gracias a todos, aqui os dejo el codigo. #include <stdio.h> #include <pthread.h> #include <stdlib.h> #include <semaphore.h> #define N 50 sem_t mutex_roja; // Se inicializa a 1 sem_t mutex_azul; // Se inicializa a 1 sem_t lleno_roja; // Se inicializa a 0 , indica cuantas piezas rojas hay en el buffer. sem_t lleno_azul; // Se inicializa a 0 , indica cuantas piezas azules hay en el buffer sem_t vacio_roja; // Se inicializa a 50, que son los huecos que tiene el buffer rojo sem_t vacio_azul; // se inicializa a 50, que son los huecos que tiene el buffer azul int entrada_roja = 0; // las piezas que he puesto rojas int entrada_azul = 0; // las piezas que he puesto azules int salida_roja = 0; // las piezas que salen rojas int salida_azul = 0; // las piezas que salen azules int buffer_roja[N] ; // buffer rojo int buffer_azul[N] ; // buffer azul int contador_roja = 0; // piezas que hay en el buffer rojo int contador_azul = 0; // piezas que hay en el buffer azul /****************************************************************************** * Funciones ******************************************************************************/ // Productor void *productor_roja() { int piezas_roja; while(1) { piezas_roja = producir_roja(); sem_wait(&vacio_roja); sem_wait(&mutex_roja); buffer_roja[entrada_roja] = piezas_roja; entrada_roja = (entrada_roja + 1); sleep(1); printf("He producido una pieza roja \n"); contador_roja++; sem_post(&mutex_roja); sem_post(&lleno_roja); } } void *productor_azul() { int piezas_azul; while(1) { piezas_azul = producir_azul(); sem_wait(&vacio_azul); sem_wait(&mutex_azul); buffer_azul[entrada_azul] = piezas_azul; entrada_azul = (entrada_azul + 1); sleep(1); printf("He producido una pieza azul \n"); contador_azul++; sem_post(&mutex_azul); sem_post(&lleno_azul); } } // Consumidor void *consumir() { int piezas_roja; int piezas_azul; while(1) { sem_wait(&lleno_roja); sem_wait(&mutex_roja); salida_roja = buffer_roja[salida_roja]; salida_roja = (salida_roja + 1); printf("HE CONSUMIDO UNA PIEZA roja \n"); contador_roja = contador_roja - 1; sleep(2); sem_post(&mutex_roja); sem_post(&vacio_roja); sem_wait(&lleno_azul); sem_wait(&mutex_azul); salida_azul = buffer_azul[salida_azul]; salida_azul = (salida_azul + 1); printf("HE CONSUMIDO UNA PIEZA AZUL \n"); contador_azul = contador_azul -1; sleep(2); sem_post(&mutex_azul); sem_post(&vacio_azul); consumir_azul(piezas_azul); } } // Producir int producir_roja() { printf("Contador roja = %d \n", contador_roja); } int producir_azul() { printf("Contador azul = %d \n", contador_azul); } // Consumir int consumir_roja() { printf("Contador roja = %d \n", contador_roja); } int consumir_azul() { printf("Contador azul= %d \n", contador_azul); } /****************************************************************************** * Programa principal ******************************************************************************/ int main() { // Iniciación de los semáforos sem_init(&mutex_roja, 0, 1); sem_init(&lleno_roja, 0, 0); sem_init(&vacio_roja, 0, 50); sem_init(&mutex_azul, 0, 1); sem_init(&lleno_azul, 0, 0); sem_init(&vacio_azul, 0, 50); pthread_t consumidor; pthread_t productor_rojas; pthread_t productor_azules; pthread_create(&consumidor, NULL, consumir,NULL); pthread_create(&productor_rojas, NULL, productor_roja,NULL); pthread_create(&productor_azules, NULL, productor_azul,NULL); pthread_join(consumidor, NULL); pthread_join(productor_rojas, NULL); pthread_join(productor_azules, NULL); return 0; } Título: Re: semáforos, memoria compartida Publicado por: javier_cj93 en 19 Noviembre 2015, 20:08 pm Ya lo he conseguido solucionar, tenía muchisimos errores. Un saludo, y gracias de todos modos.
Podéis cerrar el tema. |