Abbiamo esaminato un listato inerente la programmazione concorrente, ma, obiettivamente, il listato presentato è puramente accademico, in quanto non solo non reputo personalmente utile utilizzare due thread per una printf, ma non credo sarebbe servito direttamente il programma.

Fatta questa (dovuta) premessa, continuiamo la trattazione facendo vedere il REALE motivo per cui si lavora in programmazione concorrente, ovvero l’accesso alla memoria condivisa.

#include
#include
#include #define MAX 10

pthread_mutex_t M; /* def.mutex condiviso tra threads */

int DATA=0; /* variabile condivisa */

int accessi1=0; /*num. di accessi del thread 1 alla sez critica */
int accessi2=0; /*num. di accessi del thread 2 alla sez critica */

void *thread1_process (void * arg)
{ int k=1;
while(k)
{
pthread_mutex_lock(&M); /*prologo */
accessi1++;
DATA++;
k=(DATA>=MAX?0:1);
printf(“accessi di T1: %d\n”, accessi1);
pthread_mutex_unlock(&M); /*epilogo */
sleep(1);
}
pthread_exit (0);
}

void *thread2_process (void * arg)
{ int k=1;
while(k)
{
pthread_mutex_lock(&M); /*prologo sez. critica */
accessi2++;
DATA++;
k=(DATA>=MAX?0:1);
printf(“accessi di T2: %d\n”, accessi2);
pthread_mutex_unlock(&M); /*epilogo sez. critica*/
sleep(1);
}
pthread_exit (0);
}

int main ()
{ pthread_t th1, th2;
/* il mutex e` inizialmente libero: */
pthread_mutex_init (&M, NULL);
if (pthread_create(&th1, NULL, thread1_process, NULL) < 0)
{ fprintf (stderr, "create error for thread 1\n");
exit (1);
}
if (pthread_create(&th2, NULL,thread2_process,NULL) < 0)
{ fprintf (stderr, "create error for thread 2\n");
exit (1);
}
pthread_join (th1, NULL);
pthread_join (th2, NULL);

printf("Accessi: T1: %d, T2 %d\n",accessi1,accessi2);
}

Commentiamo il codice dall’inizio.

La priam parte è scontata, sono gli include, chi vuole vederseli vada pure qui. Dopo, definiamo una macro, che attribuisce a MAX il valore dieci per tutto il programma. (Adoro le macro di sostituzione, permettono al C di trasformarsi in qualsiasi cosa )

inizializziamo un MUTEX, tramite la variabile pthread_mutex_t, mentre DATA rappresenterà la nostra variabile condivisa. Accessi1 e Accessi2 ci mostreranno il numero di volte che i due threads accederanno alla memoria condivisa.

Cominciamo con le funzioni, che sono molto simili tra di loro come struttura, ma agiscono su variabili diverse in alcune parti.

La funzione *thread1_process inizializza una variabile k, ponendola pari ad 1, e crea un ciclo while con k funzione chiusura del ciclo.

Il ciclo è composto da:

* Lock del mutex tramite la funzione pthread_mutex_lock che accetta come argomento un riferimento ad un mutex.
* incremento degli accessi del thread e della variabile DATA
* Se data ha raggiunto il valore massimo allora il flag k diventa zero e il ciclo non si ripeterà.
* Stampa del numero di accessi
* Sblocco del mutex

Anche *thread2_process esegue un ciclo identico.

Il main alla fine effettua le seguenti operazioni:

* Crea due thread
* Inizializza il mutex creato, che inizialmente è libero
* Lancia la create per i due thread e su entrambi effettua un controllo d’errore.
* Effettua il join dei due threads

Categories: Articoli didattici.. o quasi!
No Comments »