Esercizi Threading C++
- Esercizio 1: Creazione di un semplice thread
- Esercizio 2: Passaggio di argomenti a un thread
- Esercizio 3: Thread con funzione membro
- Esercizio 4: Parallelismo con più thread
- Esercizio 5: Utilizzo di std::mutex per sincronizzare l’accesso a una variabile condivisa
- Esercizio 6: Utilizzo di std::condition_variable per la sincronizzazione dei thread
- Esercizio 7: Utilizzo di std::future e std::async per eseguire funzioni asincrone
- Esercizio 8: Utilizzo di std::thread per calcolare la somma di un array
Ecco degli esercizi con soluzione per praticare il threading di base in C++.
Esercizio 1: Creazione di un semplice thread
Creare un programma che avvia un thread separato per stampare un messaggio.
#include <iostream>#include <thread>
void stampaMessaggio() { std::cout << "Ciao dal thread!" << std::endl;}
int main() { std::thread t(stampaMessaggio); t.join(); // Attende la terminazione del thread return 0;}
Esercizio 2: Passaggio di argomenti a un thread
Creare un programma che passa un argomento a un thread e lo stampa.
#include <iostream>#include <thread>
void stampaValore(int val) { std::cout << "Valore: " << val << std::endl;}
int main() { std::thread t(stampaValore, 42); t.join(); // Attende la terminazione del thread return 0;}
Esercizio 3: Thread con funzione membro
Creare un programma che avvia un thread che esegue una funzione membro di una classe.
#include <iostream>#include <thread>
class MyClass {public: void stampaMessaggio() { std::cout << "Ciao dalla funzione membro!" << std::endl; }};
int main() { MyClass obj; std::thread t(&MyClass::stampaMessaggio, &obj); t.join(); // Attende la terminazione del thread return 0;}
Esercizio 4: Parallelismo con più thread
Creare un programma che avvia più thread per eseguire una funzione in parallelo.
#include <iostream>#include <thread>#include <vector>
void stampaMessaggio(int id) { std::cout << "Thread " << id << " in esecuzione" << std::endl;}
int main() { std::vector<std::thread> threads; for (int i = 0; i < 5; ++i) { threads.push_back(std::thread(stampaMessaggio, i)); }
for (auto& t : threads) { t.join(); // Attende la terminazione di ciascun thread }
return 0;}
Esercizio 5: Utilizzo di std::mutex per sincronizzare l’accesso a una variabile condivisa
Creare un programma che utilizza `std::mutex` per sincronizzare l'accesso a una variabile condivisa tra più thread.
#include <iostream>#include <thread>#include <mutex>
int counter = 0;std::mutex mtx;
void incrementa() { for (int i = 0; i < 1000; ++i) { std::lock_guard<std::mutex> lock(mtx); ++counter; }}
int main() { std::thread t1(incrementa); std::thread t2(incrementa);
t1.join(); t2.join();
std::cout << "Counter: " << counter << std::endl;
return 0;}
Esercizio 6: Utilizzo di std::condition_variable per la sincronizzazione dei thread
Creare un programma che utilizza `std::condition_variable` per sincronizzare due thread.
#include <iostream>#include <thread>#include <mutex>#include <condition_variable>
std::mutex mtx;std::condition_variable cv;bool ready = false;
void print_id(int id) { std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, []{ return ready; }); std::cout << "Thread " << id << std::endl;}
void go() { std::unique_lock<std::mutex> lock(mtx); ready = true; cv.notify_all();}
int main() { std::thread threads[5]; for (int i = 0; i < 5; ++i) { threads[i] = std::thread(print_id, i); }
std::cout << "Ready... Set... Go!" << std::endl; go();
for (auto& t : threads) { t.join(); }
return 0;}
Esercizio 7: Utilizzo di std::future e std::async per eseguire funzioni asincrone
Creare un programma che utilizza `std::future` e `std::async` per eseguire una funzione in modo asincrono e ottenere il risultato.
#include <iostream>#include <future>
int calcolaSomma(int a, int b) { return a + b;}
int main() { std::future<int> risultato = std::async(std::launch::async, calcolaSomma, 3, 4); std::cout << "Somma: " << risultato.get() << std::endl; // Attende il risultato della funzione asincrona return 0;}
Esercizio 8: Utilizzo di std::thread per calcolare la somma di un array
Creare un programma che utilizza `std::thread` per calcolare la somma di un array suddividendo il lavoro tra più thread.
#include <iostream>#include <thread>#include <vector>#include <numeric>
void calcolaSomma(int* arr, int start, int end, int& risultato) { risultato = std::accumulate(arr + start, arr + end, 0);}
int main() { const int size = 10; int arr[size] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int risultato1 = 0, risultato2 = 0;
std::thread t1(calcolaSomma, arr, 0, size / 2, std::ref(risultato1)); std::thread t2(calcolaSomma, arr, size / 2, size, std::ref(risultato2));
t1.join(); t2.join();
int somma_totale = risultato1 + risultato2; std::cout << "Somma totale: " << somma_totale << std::endl;
return 0;}