Esercizi Multi-Threading in C
- Esercizio 1: Creazione di un Thread
- Esercizio 2: Passaggio di Argomenti al Thread
- Esercizio 3: Creazione di Più Thread
- Esercizio 4: Utilizzo di Mutex per Sincronizzare l’Accesso a una Variabile Condivisa
- Esercizio 5: Utilizzo di Condition Variable
- Esercizio 6: Creazione di un Pool di Thread
- Esercizio 7: Utilizzo di Barrier per la Sincronizzazione di Thread
Ecco degli esercizi semplici con soluzione per praticare il multi-threading in C.
Esercizio 1: Creazione di un Thread
Creare un thread e stamparne un messaggio.
#include <stdio.h>#include <pthread.h>
void* stampa_messaggio(void* arg) { printf("Ciao dal thread!\n"); return NULL;}
int main() { pthread_t thread; pthread_create(&thread, NULL, stampa_messaggio, NULL); pthread_join(thread, NULL); return 0;}
Esercizio 2: Passaggio di Argomenti al Thread
Passare un argomento a un thread e stamparlo.
#include <stdio.h>#include <pthread.h>
void* stampa_numero(void* arg) { int numero = *((int*)arg); printf("Numero passato al thread: %d\n", numero); return NULL;}
int main() { pthread_t thread; int numero = 42; pthread_create(&thread, NULL, stampa_numero, &numero); pthread_join(thread, NULL); return 0;}
Esercizio 3: Creazione di Più Thread
Creare più thread e stampare un messaggio da ciascuno di essi.
#include <stdio.h>#include <pthread.h>
#define NUM_THREADS 5
void* stampa_messaggio(void* arg) { int thread_id = *((int*)arg); printf("Ciao dal thread %d!\n", thread_id); return NULL;}
int main() { pthread_t threads[NUM_THREADS]; int thread_ids[NUM_THREADS];
for (int i = 0; i < NUM_THREADS; i++) { thread_ids[i] = i; pthread_create(&threads[i], NULL, stampa_messaggio, &thread_ids[i]); }
for (int i = 0; i < NUM_THREADS; i++) { pthread_join(threads[i], NULL); }
return 0;}
Esercizio 4: Utilizzo di Mutex per Sincronizzare l’Accesso a una Variabile Condivisa
Utilizzare un mutex per sincronizzare l'accesso a una variabile condivisa tra due thread.
#include <stdio.h>#include <pthread.h>
int variabile_condivisa = 0;pthread_mutex_t mutex;
void* incrementa(void* arg) { pthread_mutex_lock(&mutex); for (int i = 0; i < 100000; i++) { variabile_condivisa++; } pthread_mutex_unlock(&mutex); return NULL;}
int main() { pthread_t thread1, thread2;
pthread_mutex_init(&mutex, NULL);
pthread_create(&thread1, NULL, incrementa, NULL); pthread_create(&thread2, NULL, incrementa, NULL);
pthread_join(thread1, NULL); pthread_join(thread2, NULL);
pthread_mutex_destroy(&mutex);
printf("Valore finale della variabile condivisa: %d\n", variabile_condivisa); return 0;}
Esercizio 5: Utilizzo di Condition Variable
Utilizzare una condition variable per sincronizzare due thread.
#include <stdio.h>#include <pthread.h>
pthread_mutex_t mutex;pthread_cond_t cond;int pronto = 0;
void* produttore(void* arg) { pthread_mutex_lock(&mutex); pronto = 1; printf("Produttore: dato pronto\n"); pthread_cond_signal(&cond); pthread_mutex_unlock(&mutex); return NULL;}
void* consumatore(void* arg) { pthread_mutex_lock(&mutex); while (!pronto) { pthread_cond_wait(&cond, &mutex); } printf("Consumatore: dato ricevuto\n"); pthread_mutex_unlock(&mutex); return NULL;}
int main() { pthread_t thread1, thread2;
pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond, NULL);
pthread_create(&thread1, NULL, produttore, NULL); pthread_create(&thread2, NULL, consumatore, NULL);
pthread_join(thread1, NULL); pthread_join(thread2, NULL);
pthread_mutex_destroy(&mutex); pthread_cond_destroy(&cond);
return 0;}
Esercizio 6: Creazione di un Pool di Thread
Creare un semplice pool di thread per eseguire un insieme di lavori.
#include <stdio.h>#include <pthread.h>
#define NUM_THREADS 3#define NUM_TASKS 5
void* esegui_lavoro(void* arg) { int task_id = *((int*)arg); printf("Thread %lu esegue il task %d\n", pthread_self(), task_id); return NULL;}
int main() { pthread_t threads[NUM_THREADS]; int task_ids[NUM_TASKS];
for (int i = 0; i < NUM_TASKS; i++) { task_ids[i] = i; pthread_create(&threads[i % NUM_THREADS], NULL, esegui_lavoro, &task_ids[i]); pthread_join(threads[i % NUM_THREADS], NULL); }
return 0;}
Esercizio 7: Utilizzo di Barrier per la Sincronizzazione di Thread
Utilizzare una barrier per sincronizzare l'esecuzione di più thread.
#include <stdio.h>#include <pthread.h>
#define NUM_THREADS 3
pthread_barrier_t barrier;
void* funzione(void* arg) { int thread_id = *((int*)arg); printf("Thread %d inizia a lavorare\n", thread_id); pthread_barrier_wait(&barrier); printf("Thread %d continua a lavorare dopo la barriera\n", thread_id); return NULL;}
int main() { pthread_t threads[NUM_THREADS]; int thread_ids[NUM_THREADS];
pthread_barrier_init(&barrier, NULL, NUM_THREADS);
for (int i = 0; i < NUM_THREADS; i++) { thread_ids[i] = i; pthread_create(&threads[i], NULL, funzione, &thread_ids[i]); }
for (int i = 0; i < NUM_THREADS; i++) { pthread_join(threads[i], NULL); }
pthread_barrier_destroy(&barrier);
return 0;}