Esercizi Mutex Lock C++

Ecco degli esercizi semplici con soluzione per praticare l’utilizzo dei mutex lock in C++.

Esercizio 1: Utilizzo di std::mutex per la sincronizzazione

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 increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);
        ++counter;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;

    return 0;
}

Esercizio 2: Utilizzo di std::unique_lock con std::mutex

Creare un programma che utilizza `std::unique_lock` per gestire il lock di un `std::mutex`.

#include <iostream>
#include <thread>
#include <mutex>

int counter = 0;
std::mutex mtx;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        ++counter;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;

    return 0;
}

Esercizio 3: Utilizzo di std::mutex per proteggere una sezione critica

Creare un programma che utilizza `std::mutex` per proteggere una sezione critica durante l'accesso a una risorsa condivisa.

#include <iostream>
#include <thread>
#include <vector>
#include <mutex>

std::vector<int> data;
std::mutex mtx;

void addData(int value) {
    std::lock_guard<std::mutex> lock(mtx);
    data.push_back(value);
}

int main() {
    std::thread t1(addData, 1);
    std::thread t2(addData, 2);

    t1.join();
    t2.join();

    for (int v : data) {
        std::cout << v << " ";
    }
    std::cout << std::endl;

    return 0;
}

Esercizio 4: Utilizzo di std::mutex per sincronizzare l’output

Creare un programma che utilizza `std::mutex` per sincronizzare l'output su `std::cout` da più thread.

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void printMessage(const std::string& message) {
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << message << std::endl;
}

int main() {
    std::thread t1(printMessage, "Hello from thread 1");
    std::thread t2(printMessage, "Hello from thread 2");

    t1.join();
    t2.join();

    return 0;
}

Esercizio 5: Utilizzo di std::timed_mutex per il timeout del lock

Creare un programma che utilizza `std::timed_mutex` per tentare di acquisire un lock con un timeout.

#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>

std::timed_mutex tmtx;

void attemptLock(int threadID) {
    if (tmtx.try_lock_for(std::chrono::milliseconds(100))) {
        std::cout << "Thread " << threadID << " got the lock" << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(200));
        tmtx.unlock();
    } else {
        std::cout << "Thread " << threadID << " could not get the lock" << std::endl;
    }
}

int main() {
    std::thread t1(attemptLock, 1);
    std::thread t2(attemptLock, 2);

    t1.join();
    t2.join();

    return 0;
}

Esercizio 6: Utilizzo di std::recursive_mutex per la ricorsione

Creare un programma che utilizza `std::recursive_mutex` per permettere a un thread di acquisire lo stesso mutex più volte.

#include <iostream>
#include <thread>
#include <mutex>

std::recursive_mutex rmtx;

void recursiveFunction(int count) {
    if (count > 0) {
        rmtx.lock();
        std::cout << "Lock acquired, count: " << count << std::endl;
        recursiveFunction(count - 1);
        rmtx.unlock();
        std::cout << "Lock released, count: " << count << std::endl;
    }
}

int main() {
    std::thread t(recursiveFunction, 3);
    t.join();

    return 0;
}