Certainly! Let's dive deeper into practical examples and best practices for using mutexes in C++. ### Example 1: Protecting Shared Data Consider a scenario where multiple threads need to update a shared counter. Without proper synchronization, this can lead to race conditions. ```cpp #include #include #include std::mutex mtx; int counter = 0; void increment_counter(int iterations) { for (int i = 0; i < iterations; ++i) { std::lock_guard lock(mtx); ++counter; } } int main() { const int num_threads = 10; const int iterations = 1000; std::thread threads[num_threads]; for (int i = 0; i < num_threads; ++i) { threads[i] = std::thread(increment_counter, iterations); } for (int i = 0; i < num_threads; ++i) { threads[i].join(); } std::cout << "Final counter value: " << counter << std::endl; return 0; } ``` In this example: 1. We have a shared `counter` variable. 2. Each thread increments the counter a specified number of times. 3. We use `std::lock_guard` to ensure that the `counter` is incremented safely. ### Example 2: Deadlock Avoidance Deadlocks occur when two or more threads are waiting for each other to release a resource, causing them to be stuck indefinitely. To avoid deadlocks, you can use `std::lock` to lock multiple mutexes simultaneously. ```cpp #include #include #include std::mutex mtx1, mtx2; void thread1() { std::lock(mtx1, mtx2); // Lock both mutexes without risk of deadlock std::lock_guard lock1(mtx1, std::adopt_lock); std::lock_guard lock2(mtx2, std::adopt_lock); std::cout << "Thread 1 has locked both mutexes" << std::endl; } void thread2() { std::lock(mtx1, mtx2); // Lock both mutexes without risk of deadlock std::lock_guard lock1(mtx1, std::adopt_lock); std::lock_guard lock2(mtx2, std::adopt_lock); std::cout << "Thread 2 has locked both mutexes" << std::endl; } int main() { std::thread t1(thread1); std::thread t2(thread2); t1.join(); t2.join(); return 0; } ``` In this example: 1. Both `thread1` and `thread2` need to lock `mtx1` and `mtx2`. 2. Using `std::lock` ensures that both mutexes are locked without causing a deadlock. 3. `std::adopt_lock` is used to indicate that the mutexes are already locked. ### Example 3: Using `std::unique_lock` for More Flexibility `std::unique_lock` provides more flexibility than `std::lock_guard`, such as the ability to lock and unlock the mutex multiple times. ```cpp #include #include #include std::mutex mtx; void print_even_numbers() { std::unique_lock lock(mtx); for (int i = 0; i <= 10; i += 2) { std::cout << "Even: " << i << std::endl; lock.unlock(); // Unlock the mutex std::this_thread::sleep_for(std::chrono::milliseconds(100)); lock.lock(); // Lock the mutex again } } void print_odd_numbers() { std::unique_lock lock(mtx); for (int i = 1; i <= 9; i += 2) { std::cout << "Odd: " << i << std::endl; lock.unlock(); // Unlock the mutex std::this_thread::sleep_for(std::chrono::milliseconds(100)); lock.lock(); // Lock the mutex again } } int main() { std::thread t1(print_even_numbers); std::thread t2(print_odd_numbers); t1.join(); t2.join(); return 0; } ``` In this example: 1. `std::unique_lock` is used to lock and unlock the mutex multiple times within the loop. 2. This allows the two threads to interleave their output, demonstrating more complex synchronization. ### Best Practices 1. **Minimize Lock Scope**: Only lock the mutex for the shortest duration necessary to avoid blocking other threads. 2. **Use RAII**: Prefer `std::lock_guard` or `std::unique_lock` to manage mutexes automatically and avoid forgetting to unlock. 3. **Avoid Nested Locks**: Nested locks can lead to deadlocks. If you must lock multiple mutexes, use `std::lock`. 4. **Check for Deadlocks**: Be mindful of potential deadlocks and design your locking strategy to avoid them. 5. **Use Condition Variables**: For more complex synchronization, consider using `std::condition_variable` along with `std::unique_lock`. By following these best practices and understanding the examples, you can effectively use mutexes to synchronize access to shared resources in your C++ programs.