**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Multithreading and Concurrency **Topic:** Synchronization primitives: Mutexes, condition variables, and locks. ### Introduction In the previous topic, we introduced the basics of multithreading in C++ using the `<thread>` library. However, as we start to work with multiple threads, it's essential to ensure that they safely access shared resources. This is where synchronization primitives come in. Synchronization primitives, such as mutexes, condition variables, and locks, are essential tools for managing concurrency and preventing data corruption. In this topic, we'll delve deeper into these primitives and learn how to use them effectively. ### Mutexes A mutex (short for "mutual exclusion") is a synchronization primitive that allows only one thread to access a shared resource at a time. It's like a lock on a door that prevents multiple people from entering a room simultaneously. In C++, we use the `std::mutex` class from the `<mutex>` library to create a mutex. Here's an example: ```cpp #include <mutex> #include <thread> std::mutex mtx; int sharedVariable = 0; void incrementVariable() { for (int i = 0; i < 10000; i++) { mtx.lock(); // acquire the lock sharedVariable++; mtx.unlock(); // release the lock } } int main() { std::thread t1(incrementVariable); std::thread t2(incrementVariable); t1.join(); t2.join(); std::cout << "Final value of sharedVariable: " << sharedVariable << std::endl; return 0; } ``` In this example, we create a mutex `mtx` to protect the shared variable `sharedVariable`. Two threads `t1` and `t2` increment the shared variable 10,000 times each. Without the mutex, the final value of the shared variable would likely be less than 20,000 due to data corruption. However, with the mutex, the final value is always 20,000. ### Condition Variables A condition variable is a synchronization primitive that allows a thread to wait until a specific condition is satisfied. It's like waiting for a green light before proceeding. In C++, we use the `std::condition_variable` class from the `<condition_variable>` library to create a condition variable. Here's an example: ```cpp #include <mutex> #include <condition_variable> #include <thread> std::mutex mtx; std::condition_variable cv; bool ready = false; void workerThread() { // Wait until the main thread signals that it's ready std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, []{ return ready; }); // Perform some work here std::cout << "Worker thread: ready to work!" << std::endl; } int main() { std::thread t(workerThread); // Simulate some work in the main thread std::cout << "Main thread: doing some work..." << std::endl; // Notify the worker thread that we're ready { std::lock_guard<std::mutex> lock(mtx); ready = true; } cv.notify_one(); t.join(); return 0; } ``` In this example, we create a condition variable `cv` to signal when the main thread is ready for the worker thread to proceed. The worker thread waits until the condition is satisfied using `cv.wait`, and then performs some work. ### Locks A lock is a synchronization primitive that automatically acquires and releases a mutex. It's like a wrapper around the mutex that ensures the mutex is properly released when we're done with it. In C++, we use the `std::lock_guard` and `std::unique_lock` classes from the `<mutex>` library to create locks. Here's an example: ```cpp #include <mutex> #include <thread> std::mutex mtx; int sharedVariable = 0; void incrementVariable() { for (int i = 0; i < 10000; i++) { std::lock_guard<std::mutex> lock(mtx); // acquire the lock sharedVariable++; } } int main() { std::thread t1(incrementVariable); std::thread t2(incrementVariable); t1.join(); t2.join(); std::cout << "Final value of sharedVariable: " << sharedVariable << std::endl; return 0; } ``` In this example, we create a lock using `std::lock_guard` to protect the shared variable. The lock is automatically released when the function returns or an exception is thrown. ### Best Practices 1. **Use synchronization primitives consistently**: Always use the same synchronization primitives (mutexes, condition variables, locks) throughout your code to avoid confusion and ensure correct behavior. 2. **Avoid deadlocks**: A deadlock occurs when two threads are waiting for each other to release a resource. Use techniques like lock ordering and timelocks to avoid deadlocks. 3. **Use acquire-release semantics**: Use `std::lock_guard` and `std::unique_lock` to ensure that locks are properly acquired and released. ### Conclusion Synchronization primitives are essential tools for managing concurrency and preventing data corruption in multithreaded programs. By using mutexes, condition variables, and locks correctly, we can ensure that our code is safe, efficient, and scalable. Do you have any questions about synchronization primitives? Feel free to ask in the comments section below! **Next Topic:** Understanding deadlocks, race conditions, and strategies to avoid them. **Additional Resources:** * C++ Reference: `<mutex>` library * C++ Reference: `<condition_variable>` library * C++ Reference: `<thread>` library * What Every Programmer Needs to Know About Memory (PDF)