[C] Programmazione concorrente con semafori e Mutex

[beltazor85]

E' un programma concorrente che crea atomi di idrogeno e ossigeno fino a formare una molecola di acqua H2O, ovviamente i processi H o i processi O che non servono per la creazione della molecola rimangono in attesa per poi essere risvegliati.
Usa i thread ed i mutex più le variabili di condizione sui thread, ma non i semafori classici, qualcuno saprebbe aiutarmi a capire questo codice??

UNA BREVE SINTESI DI COME FUNZIONA PER CAPIRLO MEGLIO.


----------------------------------------------------
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NROFATOMS 50



pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int hnr=0,onr=0;

int okay()
{
if (hnr >= 2 && onr >= 1)
return 1;
return 0;
}

void *H(void *i)
{
pthread_mutex_lock( &mutex );
int nr = *(int *)i;
hnr++;
printf("New H atom arrived. Nr H atom %d, nr O atom %d\n",hnr,onr);
pthread_cond_signal( &cond );

while (okay() == 0)
pthread_cond_wait( &cond,&mutex );

printf("H2O created\n");
if (hnr >= 2 && onr >= 1)
{
hnr = hnr - 2;
onr = onr - 1;
}
pthread_mutex_unlock( &mutex );
}

void *O(void *i)
{
pthread_mutex_lock( &mutex );
int nr = *(int *)i;

onr++;
printf("New O atom arriwed. Nr O atom %d, nr H atom %d\n",onr,hnr);
pthread_cond_signal( &cond );

while (okay() == 0)
pthread_cond_wait( &cond,&mutex );

printf("H2O created\n");
if (hnr >= 2 && onr >= 1)
{
hnr = hnr - 2;
onr = onr - 1;
}
pthread_mutex_unlock( &mutex );
}

main()
{
pthread_t th[NROFATOMS];
int i;
srand(time(NULL));

for (i=0; i< NROFATOMS; i++)
{
if (rand()%2==0)
{
pthread_create(&th[i],NULL,&H,&i);
}
else
{
pthread_create(&th[i],NULL,&O,&i);
}
}

for (i=0; i<NROFATOMS; i++)
{
pthread_join(th[i],NULL);
}
}
-----------------------------------------------------------------

[MdE2005]

Scusa qual'è la parte che non capisci?

[beltazor85]

Originariamente inviato da MdE2005
Scusa qual'è la parte che non capisci?

Il funzionamento dei mutex e degli operatori condizionali, non capisco come funzionano e cosa fanno... se tu lo capisci ti prego di sintetizzarmi il loro funzionamento.

[MdE2005]

Hai provato qui? http://it.wikipedia.org/wiki/Mutex

[beltazor85]

Originariamente inviato da MdE2005
Hai provato qui? http://it.wikipedia.org/wiki/Mutex

Si la teoria l'ho letta, nello specifico di questo caso capire come gli vengono passati gli argomenti, e come si usa la variabile di condizione sempre in questo caso.. ripeto la teoria l'ho letta però questo codice non l'ho scritto io e ho postato perchè magari qui per voi è facile leggerlo e capirlo subito

[veltro]

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

#define NROFATOMS 50
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int hnr=0,onr=0;

Iniziamo dal main:

main(){
pthread_t th[NROFATOMS]; //dichiara 50 variabili di tipo pthread_t
int i;
srand(time(NULL)); //insemina la funzione rand() per i numeri casuali

for (i=0; i< NROFATOMS; i++){
if (rand()%2==0){
pthread_create(&th[i],NULL,&H,&i); /*viene eseguita la funzione H come thread, &i rappresenta il passaggio di
parametro i alla funzione H */
}
else{
pthread_create(&th[i],NULL,&O,&i);
}
}

for (i=0; i<NROFATOMS; i++)
{
pthread_join(th[i],NULL);//con questa chiamata viena attesa la terminazione di tutti i thread da parte del server
}
}



int okay()
{
if (hnr >= 2 && onr >= 1)
return 1;
return 0;
}
/**
*ammettiamo che venga lanciata prima la funzione O,
**/
void *O(void *i)
{
pthread_mutex_lock( &mutex ); // blocca il mutex
int nr = *(int *)i;

onr++;
printf("New O atom arriwed. Nr O atom %d, nr H atom %d\n",onr,hnr);
pthread_cond_signal( &cond ); /*segnala la variabile di condizione e sblocca un thread in attesa di questa,
essendo la prima funzione in esecuzione non succede nulla*/

while (okay() == 0)
pthread_cond_wait( &cond,&mutex );/* se ok restituisce 0, questa chiamata sblocca il mutex e pone il thread nello stato di attesa della condizione cond, fa si che il thread non consumi tempo di CPU fino a quando la condizione non venga segnalata e subito prima di ritornare riaquisisce il controllo del mutex */

printf("H2O created\n");
if (hnr >= 2 && onr >= 1)
{
hnr = hnr - 2;
onr = onr - 1;
}
pthread_mutex_unlock( &mutex );//blocca il mutex
}

/**
*ammettiamo ora che venga eseguita la funzione H, questa blocca il mutex precedentemente sbloccato da O
*e lancia pthread_cond_signal(&cond) che riattiva il primo thread su O il quale pero'moncandogli un altro H, si rimete *in stato di wait.
**/

void *H(void *i)
{
pthread_mutex_lock( &mutex );
int nr = *(int *)i;
hnr++;
printf("New H atom arrived. Nr H atom %d, nr O atom %d\n",hnr,onr);
pthread_cond_signal( &cond );

while (okay() == 0)
pthread_cond_wait( &cond,&mutex );/*anche Il thread su H si mette in stato di wait in attesa della segnalazione della variabile cond*/

printf("H2O created\n");
if (hnr >= 2 && onr >= 1)
{
hnr = hnr - 2;
onr = onr - 1;
}
pthread_mutex_unlock( &mutex );
}

/*Ora il terzo threadche viene lanciato su H riattiva il thread in wait chiamato su O, il quale esce dal ciclo while e stampa H2O created, sblocca il mutex e termina.

Il problema di questo programma, secondo me, sta nel fatto che rimarranno sempre dei thread in wait e il main non temina mai per effetto della chiamata phtread_join.

Spero di essere stato chiaro, ciao.

[beltazor85]

Sei stato chiarissimo... si comunque rimangono sempre dei thread in attesa eterna perchè non arrivano più nuovi atomi..
Grazie mille ora ho capito veramente il funzionamento