**Course Title:** Modern C++ Programming: Mastering C++ with Best Practices and Advanced Techniques **Section Title:** Multithreading and Concurrency **Topic:** Implement a multithreaded program using mutexes and condition variables, and solve concurrency issues. (Lab topic) **Overview** In this lab, you'll learn how to implement a multithreaded program using mutexes and condition variables, and solve concurrency issues. You'll apply the concepts learned in the previous topics, including mutexes, condition variables, and locks, to create a program that runs multiple threads concurrently. **Prerequisites** Before starting this lab, make sure you have a good understanding of the following topics: * Mutexes, condition variables, and locks in C++ (covered in the "Synchronization primitives: Mutexes, condition variables, and locks" topic) * Deadlocks, race conditions, and strategies to avoid them (covered in the "Understanding deadlocks, race conditions, and strategies to avoid them" topic) **Task** Create a multithreaded program that simulates a bank account system. The program should have the following features: * Multiple threads that deposit and withdraw money from the account * Use mutexes to protect shared data (account balance) from concurrent access * Use condition variables to signal threads when the account balance has changed **Implementation** Here's an example implementation to get you started: ```cpp #include <iostream> #include <thread> #include <mutex> #include <condition_variable> class BankAccount { public: BankAccount() : balance(0) {} void deposit(int amount) { std::lock_guard<std::mutex> lock(mutex); balance += amount; std::cout << "Deposited: " << amount << ", Balance: " << balance << std::endl; cond.notify_all(); } void withdraw(int amount) { std::unique_lock<std::mutex> lock(mutex); while (balance < amount) { cond.wait(lock); } balance -= amount; std::cout << "Withdrawn: " << amount << ", Balance: " << balance << std::endl; } int getBalance() const { std::lock_guard<std::mutex> lock(mutex); return balance; } private: int balance; std::mutex mutex; std::condition_variable cond; }; int main() { BankAccount account; std::thread t1([&account]() { account.deposit(100); account.withdraw(50); account.deposit(200); }); std::thread t2([&account]() { account.withdraw(150); account.deposit(300); account.withdraw(100); }); t1.join(); t2.join(); std::cout << "Final Balance: " << account.getBalance() << std::endl; return 0; } ``` **Key Concepts** * Mutexes (`std::mutex`) protect shared data from concurrent access * Condition variables (`std::condition_variable`) signal threads when a specific condition occurs (e.g., account balance has changed) * Locks (`std::lock_guard` and `std::unique_lock`) ensure that threads access shared data in a thread-safe manner * Use `notify_all()` to signal all threads waiting on a condition variable **Best Practices** * Always use mutexes to protect shared data from concurrent access * Use condition variables to signal threads when a specific condition occurs * Use locks to ensure that threads access shared data in a thread-safe manner * Avoid busy-waiting by using condition variables instead of infinite loops **Common Pitfalls** * Deadlocks: occur when two or more threads are blocked indefinitely, waiting for each other to release a resource. To avoid deadlocks, always release locks in the reverse order they were acquired. * Race conditions: occur when two or more threads access shared data simultaneously, resulting in unexpected behavior. To avoid race conditions, use mutexes to protect shared data and ensure that threads access shared data in a thread-safe manner. **Exercise** Modify the example program to use a `std::atomic<int>` instead of a `std::mutex` to protect the account balance. What are the benefits and limitations of using atomic variables in this context? **External Resources** * C++11/C++14/C++17/C++20 Synchronisation library ([cppreference.com](https://en.cppreference.com/w/cpp/thread)) * Multithreading in C++ ([ tutorialspoint.com](https://www.tutorialspoint.com/cplusplus/cpp_multithreading.htm)) **Leave a Comment or Ask for Help** If you have any questions or need help with this lab, please leave a comment below.