|
|
|
|
Strumenti |
11-10-2017, 15:46 | #1 |
Junior Member
Iscritto dal: May 2006
Messaggi: 2
|
Problema produttori/consumatori
Ciao ragazzi ho un grosso problema e chiedo il vostro aiuto.......Potete per favore aiutarmi??????Non ho molta dimistichezza....
Mi occore scrivere il codice per il problema produttori/consumatori utilizzando una struttura buffer e due condition variable non pieno e non vuoto.Poi utilizzare 3 mutex per proteggere l'accesso alle variabili condivise: il buffer, l'indice delle estrazioni e l'indice degli inserimenti. Per inserire si valuta il buffer per controllare se è pieno, se lo è per il caso bloccante si attende una notifica di un'eliminazione di un messaggio, altrimenti si ritorna errore per quello non bloccante. Se il buffer non è pieno, si inserisce il messaggio e si aggiorna il numero di messaggi contenuti. Dualmente si procede per il consumo, si verifica se il buffer è vuoto, si attende per una notifica di avvenuto inserimento messaggio per il caso bloccante, mentre si ritorna un errore per il caso non bloccante. Nel caso di buffer non vuoto, si ritorna il messaggio e lo si elimina dal buffer. |
13-10-2017, 13:11 | #2 |
Junior Member
Iscritto dal: May 2006
Messaggi: 2
|
Ho trovato questo ma sembra non funzionare.....qualcuno mi puo aiutare???Ecco:
#include<stdio.h> #include<stdlib.h> #include<pthread.h> #include<string.h> #define BUFFERERROR (msg_t *) NULL; typedef char* stringa; typedef struct msg { void* content; // generico contenuto del messaggio struct msg * (*msg_init_string)(void*); // creazione msg void (*msg_destroy_string)(struct msg *); // deallocazione msg struct msg * (*msg_copy_string)(struct msg *); // creazione/copia msg } msg_t; typedef struct buffer{ int K; //numero messaggi inseriti int N; //capacita buffer circolare int D; int T; msg_t **buffer_circolare; pthread_mutex_t mutex; pthread_cond_t non_pieno; pthread_cond_t non_vuoto; }buffer_t; void msg_destroy_string(msg_t* msg) { free(msg->content); // free copia privata free(msg); // free struct } msg_t* msg_copy_string(msg_t* msg) { return msg->msg_init_string( msg->content ); } msg_t* msg_init_string(void* content) { //viene creata una copia "privata" della stringa msg_t* new_msg = (msg_t*)malloc( sizeof(msg_t) ); char* string = (char*)content; char* new_content = (char*)malloc(strlen(string)+1); // +1 per \0 finale strcpy(new_content, string); new_msg->content=new_content; new_msg->msg_init_string=msg_init_string; new_msg->msg_destroy_string=msg_destroy_string; new_msg->msg_copy_string=msg_copy_string; return new_msg; } void buffer_destroy(buffer_t* buffer){ free(buffer); } buffer_t* buffer_init(unsigned int maxsize){ buffer_t *buffer; buffer = (buffer_t *)malloc(sizeof(buffer_t)); buffer->buffer_circolare = malloc(maxsize*sizeof(msg_t)); buffer->D=0; buffer->K=0; buffer->T=0; buffer->N=maxsize; pthread_mutex_init(&buffer->mutex,NULL); pthread_cond_init(&buffer->non_pieno,NULL); pthread_cond_init(&buffer->non_vuoto,NULL); return buffer; } msg_t* put_non_bloccante(buffer_t *buffer){ pthread_mutex_lock(&buffer->mutex); if(buffer->K==buffer->N){ printf("Il buffer è pieno e il mutex è rilasciato\n"); pthread_mutex_unlock(&buffer->mutex); return NULL; }else{ msg_t* msg=msg_init_string("Messaggio"); buffer->buffer_circolare[buffer->D]=msg_copy_string(msg); printf("Il produttore inserisce il messaggio\n"); buffer->D=(buffer->D+1)%buffer->N; buffer->K=buffer->K+1; pthread_cond_signal(&buffer->non_vuoto); pthread_mutex_unlock(&buffer->mutex); return msg; } } msg_t* put_bloccante(buffer_t *buffer){ msg_t *msg = msg_init_string("Messaggio"); pthread_mutex_lock(&buffer->mutex); while(buffer->K==buffer->N){ printf("Il Produttore è in attesa che il buffer sia vuoto\n"); pthread_cond_wait(&buffer->non_pieno,&buffer->mutex); } buffer->buffer_circolare[buffer->D]=msg_copy_string(msg); printf("Il produttore inserisce il messaggio\n"); buffer->D=(buffer->D+1)%buffer->N; buffer->K=buffer->K+1; pthread_cond_signal(&buffer->non_vuoto); pthread_mutex_unlock(&buffer->mutex); return msg; /**}else return BUFFERERROR;*/ } msg_t* get_bloccante(buffer_t* buffer){ msg_t*result; pthread_mutex_lock(&buffer->mutex); while(buffer->K==0){ printf("Il consumatore è in attesa che il buffer venga riempito\n"); pthread_cond_wait(&buffer->non_vuoto,&buffer->mutex); } printf("Il consumatore preleva un messaggio\n"); result=(msg_t*)malloc( sizeof(msg_t) ); result=buffer->buffer_circolare[buffer->T]; buffer->buffer_circolare[buffer->T]=NULL; buffer->T=(buffer->T+1)%buffer->N; buffer->K=buffer->K-1; pthread_cond_signal(&buffer->non_pieno); pthread_mutex_unlock(&buffer->mutex); return result; } msg_t* get_non_bloccante(buffer_t* buffer){ pthread_mutex_lock(&buffer->mutex); if(buffer->K==0){ printf("Il consumatore non preleva poiche buffer vuoto\n"); pthread_mutex_unlock(&buffer->mutex); return NULL; }else{ printf("Il consumatore preleva un messaggio\n"); msg_t* result=(msg_t*)malloc( sizeof(msg_t) ); result=msg_copy_string(buffer->buffer_circolare[buffer->T]); buffer->buffer_circolare[buffer->T]=NULL; buffer->T=(buffer->T+1)%buffer->N; buffer->K=buffer->K-1; pthread_cond_signal(&buffer->non_pieno); pthread_mutex_unlock(&buffer->mutex); return result; } } msg_t* dummy_produttore(buffer_t* buffer){ msg_t *msg = msg_init_string("Messaggio"); pthread_mutex_lock(&buffer->mutex); buffer->buffer_circolare[buffer->D]=msg_copy_string(msg); printf("Il produttore inserisce il messaggio\n"); buffer->D=(buffer->D+1)%buffer->N; buffer->K=buffer->K+1; pthread_cond_signal(&buffer->non_vuoto); pthread_mutex_unlock(&buffer->mutex); return msg; } msg_t* dummy_consumatore(buffer_t* buffer){ msg_t*result; pthread_mutex_lock(&buffer->mutex); printf("Il consumatore preleva un messaggio\n"); result=(msg_t*)malloc( sizeof(msg_t) ); result=buffer->buffer_circolare[buffer->T]; buffer->buffer_circolare[buffer->T]=NULL; buffer->T=(buffer->T+1)%buffer->N; buffer->K=buffer->K-1; pthread_cond_signal(&buffer->non_pieno); pthread_mutex_unlock(&buffer->mutex); return result; } |
13-10-2017, 14:24 | #3 | |
Senior Member
Iscritto dal: Apr 2010
Città: Leuven
Messaggi: 667
|
Quote:
A parte questo... Il problema del produttore e consumatore è super facile da risolvere, sforzati un po'! Soprattutto se usi windows, il codice che hai postato non funziona, ti manca pthread.h -> POSIX threads. Puoi scaricarlo da qui: https://sourceforge.net/projects/pthreads4w/ Oppure, se usi visual studio potresti usare i thread di windows: https://msdn.microsoft.com/en-us/lib...(v=vs.85).aspx Oppure se puoi usare c++11 (o 14 o 17) puoi usare std::thread: http://en.cppreference.com/w/cpp/thread/thread Se puoi usare Java o Python è ancora più facile!
__________________
L'elettronica digitale non esiste, è solo elettrotecnica con interruttori piccoli! |
|
Strumenti | |
|
|
Tutti gli orari sono GMT +1. Ora sono le: 01:09.