Due threads giocano a dadi

 /*
  * Svolgi un gioco di dadi utilizzando i meccanismi di thread e mutex.
  * Il primo thread deve lanciare un dado e comunicarne il risultato al secondo.
  * Il secondo thread tira un secondo dado e leggendo il valore del dado del primo thread decreta il vincitore. Il secondo thread chiederà al primo se vorrà giocare di nuovo con i dadi.
  * Se il primo thread accetta (mediante una risposta diretta dell'utente) si tireranno di nuovo i dadi dopo aver restituito l'info al secondo thread.
  * In caso contrario si chiude l'esecuzione. Il thread primario deve attendere lo stato di terminazione del secondo thread.
  */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <string.h>

#define FACCE 12

void * gestore_thread(void * argomento);
int run = 1, res;
pthread_mutex_t mut1, mut2;

int main(void){
    pthread_t thread;
    srand(getpid());
    pthread_mutex_init(&mut1, NULL);
    pthread_mutex_init(&mut2, NULL);
    int num1;

    while (run){
        //1. il primo thread lancia un dado
        pthread_mutex_lock(&mut1);
        num1 = rand() % FACCE + 1;
        printf("\nA: Ho tirato il primo dado, mi e' uscito %d.\n", num1);
        //2. crea il secondo thread mandandogli il risultato e poi si blocca
        res = pthread_create(&thread, NULL, gestore_thread, (void *)num1);
        if(res){
            puts("Errore nella pthread_create!!");
            exit(EXIT_FAILURE);
        }

        printf("A: Ho creato il secondo thread. Ora vado a dormire.\n");
        pthread_mutex_lock(&mut1);
        //6. si sveglia. due casi
        printf("\nA: Sono di nuovo sveglio. Mh fammi pensare... 1 = continua, 0 = esci\n");
        scanf("%d", &run);
        //7a. se accetta, restituisce l'info al secondo thread che fa la join e si ricomincia il ciclo while
        pthread_mutex_unlock(&mut2);
        pthread_join(thread, NULL);
        printf("A: Ho completato la join.\n\n\n");
        pthread_mutex_unlock(&mut1);
        //fine while
    }
    //7b. se rifiuta, si chiude l'esecuzione del secondo thread con la join e poi del primo

    //pulizia
    pthread_mutex_destroy(&mut1);
    pthread_mutex_destroy(&mut2);

    exit(EXIT_SUCCESS);
}

void * gestore_thread(void * argomento){
    //3. parte il secondo thread e tira un dado
    pthread_mutex_lock(&mut2);
    printf("\nB: Eccomi, sono il secondo thread. Mi e' giunta voce che ti e' uscito %d.\n", (int)argomento);
    int num2 = rand() % FACCE + 1;
    printf("B: A me, invece, e' uscito %d.\n", num2);
    //4. confronta il risultato con quello del primo e decreta il vincitore
    if ((int)argomento > num2)
        printf("B: Questo significa che ho perso!\n");
    else if ((int)argomento < num2)
        printf("B: Questo significa che ho vinto!\n");
    else
        printf("B: Questo significa che abbiamo pareggiato...\n");
    //5. chiede al primo thread se vuole giocare ancora. si blocca
    printf("\nB: Vuoi giocare ancora, thread A?\n");
    pthread_mutex_unlock(&mut1);
    pthread_mutex_lock(&mut2);
    //8. il thread controlla il valore di run e fa la join
    printf("\n\nB: Sono sveglio. Hai scelto %d.. In ogni caso adesso faccio la exit.\n", run);
    pthread_mutex_unlock(&mut2);
    pthread_exit(NULL);
}