Esercizi Threading C++

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;
}