PDA

Visualizza la versione completa : [c] Esercizio di Sistemi operativi su produttore e consumatore, è giusto??


angelo85ct
04-06-2010, 11:39
/* 3 thread produttore e 2 consumatori condividono un array statico di 20 elementi definito come segue:
1. TID del produttore
2. Numero progressivo di scrittura autonomo per ogni produttore

Si hanno le seguenti specifiche:
- le attività di produzione indipendenti (fuori dalla sezione critica) devono durare 1s.
- le attività di consumo indipendente (fuori dalla sezione critica) durano 4s. Il numero di elementi consumati è pari alla metà degli elementi presenti dentro la array.

Stampare:
- attività indipendente di creazione dell'elemento da parte del produttore;
- attività di consumo indip. da parte del consumatore, che consiste nella stampa a video di identificatore del consumatore e dei campi dell'elemento consumato. */


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

#define DIMENSIONE 20
int array[DIMENSIONE];

#define NP 3
#define NC 2

int inserito = 0;
int estratto = 0;

pthread_mutex_t mutex; //Semaforo binario per la mutua esclusione

pthread_cond_t attesa_per_spazio; //Si addormenta perchè non c'è spazio!
pthread_cond_t attesa_per_dati; //Si addormenta perchè non c'è niente da leggere!

int flag = 0; //Con 0 inizia il produttore!

//FUNZIONE DEL PRODUTTORE - int i perchè abbiamo più produttori, altrimenti era vuoto ()
void *produttore(int i){
int cont = 0; //indice che scorre l'array
while(1){ //Cicla per un numero infinito di volte, e' come dire 1=0 che e' sempre verificata
pthread_mutex_lock (&mutex); //Setto mutex = lock ed entro in sezione critica
//Inizio sezione critica
printf("Sono il produttore %d: sono in sezione critica\n", inserito);

while(cont == DIMENSIONE) //se il flag = 1 il produttore ha finito di produrre, cioè l'array e' pieno!
pthread_cond_wait(&attesa_per_spazio, &mutex); //si mette in attesa ed in ascolto sulla cond_var e sblocca il mutex e consente l'esecuzione dell'altro thread
array[cont] = inserito;
inserito ++;
cont ++;


pthread_mutex_unlock(&mutex);
//Fine della sezione critica!
sleep(1);
}
}

//FUNZIONE DEL CONSUMATORE
void *consumatore(int i){
while (1){
pthread_mutex_lock (&mutex);
while (estratto == DIMENSIONE) //L'array e' vuoto
pthread_cond_wait (&attesa_per_dati, &mutex);
printf("Ho estratto %d\n", array[estratto]);
estratto ++;
// SI DOVREBBE FARE UN FOR CON (DIMENSIONE - ESTRATTI/2)

pthread_cond_broadcast (&attesa_per_spazio);
pthread_mutex_unlock(&mutex);
sleep(4);
}
}

int main(){
pthread_t prod[NP];
pthread_t cons[NC];

pthread_mutex_init (&mutex, NULL);
pthread_cond_init (&attesa_per_spazio, NULL);
pthread_cond_init (&attesa_per_dati, NULL);

int i = 0;

for(i=0; i<NP; i++)
pthread_create (&prod[i], NULL, (void*) produttore, (void*) i);

for(i=0; i<NC; i++)
pthread_create (&cons[i], NULL, (void*) consumatore, (void*) i);

pthread_exit(NULL);
}


Chi mi sa dire se è giusto o no e come si fa sto coso?? Non ci capisco :cry: :cry: :dhò: :dhò: molto e sto impazzendo, grazie

Loading