pthread_t pthread_self(void)

int pthread_equals(pthread_t tid1, pthread_t tid2);

/**
* @param thread: puntatore ad identificatore di thread dove verrà scritto l'ID del thread creato
* @param attr: attributi del thread, NULL per usare valori di default
* @param start_routine: puntatore alla funzione che contiene il codice del nuovo thread
* @param arg puntatore che viene passato come argomento a `start_routine`
*
* @returns `0` in assenza di errore, un valore diverso altrimenti
*/
int pthread_create( pthread_t* thread,
					const pthread_attr_t* attr,
					void* (*start_routine)(void*),
					void* arg );

/**
* L'esecuzione del thread termina e il sistema libera le risorse allocate
* Se un thread padre termina i figli **continuano la loro esecuzione**,
* tranne quelli nello stato `zombie`, che terminano a loro volta.
*
* @param retaval valore di ritorno del thread consultabile da altri thread utilizzando la @ref `pthread_join`
*/
void pthread_exit(void* retval);

/**
* Blocca un thread in attesa della terminazione di un thread specifico.
*
* @param thread ID del thread di cui attendere la terminazione
* @param retval puntatore al puntatore dove verrà salvato l'indirizzo restituito dal thread con la @ref `pthread_exit`.
*				Può essere impostato a `NULL` in caso volessimo ignorarlo.
*
*
* @returns `0` in caso di successo, altrimenti un codice di errore.
*/
int pthread_join(pthread_t thread, void** retval);

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

/* Corpo del thread */
void* tr_code(void* arg) {
	printf("Hello World! My arg is %d\n", *(int*)arg);
	free(arg);
	pthread_exit(NULL);
}

int main() {
	pthread_t t1, t2;
	int* arg1 = (int*)malloc(sizeof(int));
	int* arg2 = (int*)malloc(sizeof(int));

	*arg1 = 1;
	*arg2 = 2;

	int ret;

	/* Creo il primo thread passandogli `1` come argomento */
	ret = pthread_create(&tr1, NULL, tr_code, arg1);
	if (ret) {
		printf("Error: return code from pthread_create is %d\n", ret);
		exit(-1);
	}

	/* Creo il secondo thread passandogli `2` come argomento */
	ret = pthread_create(&tr2, NULL, tr_code, arg2);
	if (ret) {
		printf("Error: return code from pthread_create is %d\n", ret);
		exit(-1);
	}

	//! ATTENZIONE
	// La create non ha mandato in esecuzione i thread, quello è scelto dallo schedulatore
	pthread_exit(NULL);
}

// ... headers
#define NTHREADS 10

// ... thread code

int main() {
	pthread_t tr[NTHREADS];
	int* args[NTHREADS];
	int ret;
	for (int i = 0; i < NTHREADS; ++i) {
		args[i] = (int*)malloc(sizeof(int));
		args[i] = i;
		ret = pthread_create(&tr[i], NULL, tr_code, args[i]);
		if (ret) {
			printf("Error: return code from pthread_create is %d\n", ret);
			exit(-1);
		}
	}

	pthread_exit(NULL);
}

// Definire una variabile mutex
pthread_mutex_t M;

/**
* Permette di inizializzare la variabile mutex.
*
* @param M puntatore al mutex da inizializzare
* @param mattr puntatore a una struttura con attributi di inizializzazione. Se `NULL` vengono utilizzati i valori di default (mutex libero)
*
* @returns
*/
int pthread_mutex_init(pthread_mutex_t* M, const pthread_mutexattr_t* mattr);

// Entrambe restituiscono `0` in caso di successo, altrimenti un codice di errore

int pthread_mutex_lock(pthread_mutex_t* M);
int pthread_mutex_unlock(pthread_mutex_t* M);

pthread_mutex_t M;

// ...

pthread_mutex_init(&M, NULL);

// Voglio utilizzare la risorsa
if (pthread_mutex_lock(&M)) {
	// Errore nella presa del lock
}

// Utilizzo la risorsa

// Rilascio la risorsa
if (pthread_mutex_unlock(&M)) {
	// Errore nel rilascio del lock
}
// Risorsa rilasciata

pthread_cond_t C;

/**
* Inizializza una condition variable
* @param C puntatore alla condition variable da inizializzare
* @param attr attributi specificati per la condizione. Se `NULL` inizializzata a default
*/
int pthread_cond_init(pthread_cond_t* C, pthread_cond_attr_t* attr);

/*
* Si utilizza while perché il thread potrebbe essere risvegliato anche se la condizione logica non è stata modificata
* È quindi necessario ricontrollare la condizione dopo essere statis svegliati
*/
while (condizione_logica) {
	wait(condition_variable);
}

/**
* Sospende un thread nella coda associata a `C` e gestisce automaticamente
* il lock sulla risorsa `M`
*
* @param C variable condition sulla quale sospendersi
* @param M mutex associato alla condizione
*/
int pthread_cond_wait(pthread_cond_t* C, pthread_mutex_t* M);


/**
* Permette di risvegliare un thread sospeso su una condition variable `C`.
* Se non ci sono thread in attesa **non ha alcun effetto**.
* Se ci sono più thread in attesa ne viene scelto **uno a caso**
*
* @param C variable condition sulla quale risvegliare il processo
*/
int pthread_cond_signal(pthread_cond_t* C);

/**
* Permette di risvegliare **tutti** i thread sospesi su una condition variable `C`.
* Se non ci sono thread in attesa **non ha alcun effetto**.
*
* @param C variable condition sulla quale risvegliare i processo
*/
int pthread_cond_broadcast(pthread_cond_t* C);

typedef struct {
	int buffer[BUFFER_SIZE];
	itn readInd, writeInd;
	int cont;

	pthread_mutex_t M;

	pthread_cond_t FULL;
	pthread_cond_t EMPTY;
} risorsa;

risorsa r;
int main() {
	pthread_mutex_init(&r.M, NULL);

	pthread_cond_init(&r.FULL, NULL);
	pthread_cond_init(&r.EMPTY, NULL);

	r.readInt = r.writeInd = r.cont = 0;
	// ...
}

#define MAX_T 10

int n_users = 0;
pthread_cond_t FULL;
pthread_mutex_t M;

// ...

// ...

pthread_mutex_lock(&M);

while (n_users == MAX_T) {
	pthread_cond_wait(&FULL, &M);
}

n_users++;
pthread_mutex_unlock(&M);

// Utilizzo la risorsa

// ...

pthread_mutex_lock(&M);

n_users--;
pthread_cond_signal(&FULL);

pthread_mutex_unlock(&M);