Esercizi Mutex Lock C++
- Esercizio 1: Utilizzo di std::mutex per la sincronizzazione
- Esercizio 2: Utilizzo di std::unique_lock con std::mutex
- Esercizio 3: Utilizzo di std::mutex per proteggere una sezione critica
- Esercizio 4: Utilizzo di std::mutex per sincronizzare l’output
- Esercizio 5: Utilizzo di std::timed_mutex per il timeout del lock
- Esercizio 6: Utilizzo di std::recursive_mutex per la ricorsione
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;}