Mensajes

Ya lo he conseguido solucionar, tenía muchisimos errores. Un saludo, y gracias de todos modos.

Podéis cerrar el tema.

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;
}