Esercizi Parallelismo C++

Ecco degli esercizi semplici con soluzione per praticare il parallelismo in C++ utilizzando thread.

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