[Erlug] threads

[Simone Saravalli [Permanent Link]]

Salve a tutti,
    sto tentando di realizzare un programma per risolvere il problema del
producer--consumer. Quello che non riesco ad ottenere, anche se il codice mi
sembra corretto, è un buffer di dimensione limitata, ma circolare, ossia, il
producer arriva a memorizzare fino all'ultimo elemento e poi riparte dal primo.
Invece il mio output mi indica che vengono creati 100 oggetti e che ne vengono
mangiati altrettanti, ma poi il tutto non riparte da capo. Perchèèèè?
Vi posto anche il mio codice se dovesse essere d'aiuto per comprendere meglio il
mio problema.

Grazie

Simone Saravalli



#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <errno.h>
#include <semaphore.h>

#define MAXNITEMS 100
#define MAXNTHREAD 10

int j;
int buffer[MAXNITEMS];

struct{
   pthread_mutex_t mutex;
   int nput;
   int nval;
}put={PTHREAD_MUTEX_INITIALIZER};

struct{
   pthread_mutex_t mutex;
 pthread_cond_t cond;
   int nready;
}nready={PTHREAD_MUTEX_INITIALIZER,PTHREAD_COND_INITIALIZER};


void *produce (void *arg){
   while(1) {
      pthread_mutex_lock(&put.mutex);

      if(put.nput>=MAXNITEMS){
         pthread_mutex_unlock(&put.mutex);
         return(NULL);
      }

      buffer[put.nput]=put.nval;
  printf ("Produce element %d in buffer[%d]\n", put.nval, put.nput);
      (put.nput)++;
      (put.nval)++;
      pthread_mutex_unlock(&put.mutex);

      pthread_mutex_lock(&nready.mutex);
      if(nready.nready==0)
         pthread_cond_signal(&nready.cond);
      (nready.nready)++;
      pthread_mutex_unlock(&nready.mutex);

      *(int *)arg+=1;
   }
}

void *consume(void *arg){
   for(j=0;j<MAXNITEMS;j++){
      pthread_mutex_lock(&nready.mutex);
      while(nready.nready==0)
         pthread_cond_wait(&nready.cond,&nready.mutex);
      printf ("Eat element %d\n", nready.nready);
  nready.nready--;
      pthread_mutex_unlock(&nready.mutex);
      if(buffer[j]!=j)
         printf("Buffer[%d]=%d\n",j,buffer[j]);
   }
   return(NULL);
}

int main(int argc, char *argv[]){
 int i, count=0;
   pthread_t tid_prod;
   pthread_t tid_cons;

   //creazione thread producer

   pthread_create(&tid_prod,NULL,produce,(void*)&count);

 //creazione thread consumer

 pthread_create(&tid_cons, NULL, consume, NULL);

 //attesa terminazione thread producer

 pthread_join(tid_prod,NULL);
 printf("count=%d\n",count);

 //attesa terminazione thread consumer

 pthread_join(tid_cons,NULL);

   exit (0);
}