Mutexes

A Mutex (mutual exclusion) is used to prevent data races by ensuring that only one thread can access a shared resource at a time. In C++, you should always manage mutexes using RAII wrappers to avoid leaving locks acquired.

Reader-Writer Locks (std::shared_mutex)

When a shared resource is read frequently but modified rarely, standard exclusive mutexes limit throughput. std::shared_mutex resolves this:

• Reader Path: Locks using std::shared_lock. Multiple threads can read concurrently.
• Writer Path: Locks using std::unique_lock. Blocks all other readers and writers to perform updates safely.

Code Walkthrough

A thread-safe cache class illustrating the use of reader-writer locks.

#include <iostream>
#include <shared_mutex>
#include <unordered_map>
#include <string>
class SafeCache {
private:
    mutable std::shared_mutex m_mutex;
    std::unordered_map<std::string, std::string> m_map;
public:
    // Shared Lock for reading: multiple threads can read at once
    std::string get(const std::string& key) const {
        std::shared_lock<std::shared_mutex> lock(m_mutex);
        auto it = m_map.find(key);
        return (it != m_map.end()) ? it->second : "";
    }
// Unique Lock for writing: blocks all other reads and writes
    void set(const std::string& key, const std::string& val) {
        std::unique_lock<std::shared_mutex> lock(m_mutex);
        m_map[key] = val;
    }
};
int main() {
    SafeCache cache;
    cache.set("C++", "Awesome");
    std::cout << "C++: " << cache.get("C++") << std::endl;
    return 0;
}

Interview-Relevant Information