shared_mutex

---

1. Reader-Writer Lock

class ReaderWriterLock {
    std::shared_mutex mutex;
    int readers; // Number of concurrent readers

public:
    void read() {
        mutex.lock_shared();
        ++readers;
        mutex.unlock_shared();
    }

    void write() {
        mutex.lock();
        while (readers > 0) {
            mutex.unlock();
            std::this_thread::yield();
            mutex.lock();
        }
        // Enter critical section
        ...
        // Exit critical section
        mutex.unlock();
    }
};

2. Read-Write Map

#include <unordered_map>

class ReadWriteMap {
    std::shared_mutex mutex;
    std::unordered_map<int, int> data;

public:
    int get(int key) {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data[key];
    }

    void put(int key, int value) {
        std::unique_lock<std::shared_mutex> lock(mutex);
        data[key] = value;
    }
};

3. Concurrent Queue

#include <queue>

class ConcurrentQueue {
    std::shared_mutex mutex;
    std::queue<int> data;

public:
    void enqueue(int value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data.push(value);
    }

    int dequeue() {
        std::lock_guard<std::shared_mutex> lock(mutex);
        int value = data.front();
        data.pop();
        return value;
    }
};

4. Thread-Safe Counter

class Counter {
    std::atomic<int> value;
    std::shared_mutex mutex;

public:
    int get() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return value.load();
    }

    void increment() {
        std::unique_lock<std::shared_mutex> lock(mutex);
        ++value;
    }
};

5. Guarded Data

template<typename T>
class GuardedData {
    std::shared_mutex mutex;
    T data;

public:
    void set(T value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data = value;
    }

    T get() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data;
    }
};

6. Shared Counter

class SharedCounter {
    std::atomic<int> count;
    std::shared_mutex mutex;

public:
    int get() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return count.load();
    }
};

7. Concurrent List

#include <list>

class ConcurrentList {
    std::shared_mutex mutex;
    std::list<int> data;

public:
    void add(int value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data.push_back(value);
    }

    int remove() {
        std::lock_guard<std::shared_mutex> lock(mutex);
        int value = data.front();
        data.pop_front();
        return value;
    }
};

8. Thread-Safe Queue

#include <queue>

class ThreadSafeQueue {
    std::shared_mutex mutex;
    std::queue<int> data;

public:
    void push(int value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data.push(value);
    }

    int pop() {
        std::lock_guard<std::shared_mutex> lock(mutex);
        int value = data.front();
        data.pop();
        return value;
    }
};

9. Guarded Data with Expected Value

template<typename T>
class GuardedDataWithExpectedValue {
    std::shared_mutex mutex;
    T data;
    T expectedValue;

public:
    GuardedDataWithExpectedValue(T initialValue) : data(initialValue), expectedValue(initialValue) {}

    void set(T value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        if (data == expectedValue) {
            data = value;
            expectedValue = value;
        }
    }

    T get() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data;
    }
};

10. Concurrent Histogram

#include <unordered_map>

class ConcurrentHistogram {
    std::shared_mutex mutex;
    std::unordered_map<int, int> data;

public:
    void add(int value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        ++data[value];
    }

    int get(int value) {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data[value];
    }
};

11. Thread-Safe Stack

#include <stack>

class ThreadSafeStack {
    std::shared_mutex mutex;
    std::stack<int> data;

public:
    void push(int value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data.push(value);
    }

    int pop() {
        std::lock_guard<std::shared_mutex> lock(mutex);
        int value = data.top();
        data.pop();
        return value;
    }
};

12. Concurrent Bloom Filter

#include <bitset>

class ConcurrentBloomFilter {
    std::shared_mutex mutex;
    std::bitset<1000> data;

public:
    void add(const std::string& value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data.set(std::hash<std::string>()(value) % data.size());
    }

    bool check(const std::string& value) {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data.test(std::hash<std::string>()(value) % data.size());
    }
};

13. Guarded Data with Timed Access

template<typename T>
class GuardedDataWithTimedAccess {
    std::shared_mutex mutex;
    T data;
    std::chrono::time_point<std::chrono::system_clock> lastAccessed;

public:
    GuardedDataWithTimedAccess(T initialValue) : data(initialValue), lastAccessed(std::chrono::system_clock::now()) {}

    void set(T value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data = value;
        lastAccessed = std::chrono::system_clock::now();
    }

    T get() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data;
    }

    std::chrono::time_point<std::chrono::system_clock> getLastAccessed() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return lastAccessed;
    }
};

14. Concurrent Set

#include <unordered_set>

class ConcurrentSet {
    std::shared_mutex mutex;
    std::unordered_set<int> data;

public:
    void add(int value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data.insert(value);
    }

    bool contains(int value) {
        std::shared_lock<std::shared_mutex> lock(mutex);
        return data.find(value) != data.end();
    }
};

15. Thread-Safe Circular Buffer

#include <deque>

class ThreadSafeCircularBuffer {
    std::shared_mutex mutex;
    std::deque<int> data;
    int capacity;

public:
    ThreadSafeCircularBuffer(int capacity) : capacity(capacity) {}

    void push(int value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        if (data.size() == capacity) {
            data.pop_front();
        }
        data.push_back(value);
    }

    int pop() {
        std::lock_guard<std::shared_mutex> lock(mutex);
        int value = data.front();
        data.pop_front();
        return value;
    }
};

16. Guarded Data with Condition Variable

template<typename T>
class GuardedDataWithConditionVariable {
    std::shared_mutex mutex;
    T data;
    std::condition_variable_any cv;

public:
    GuardedDataWithConditionVariable(T initialValue) : data(initialValue) {}

    void set(T value) {
        std::lock_guard<std::shared_mutex> lock(mutex);
        data = value;
        cv.notify_all();
    }

    T get() {
        std::shared_lock<std::shared_mutex> lock(mutex);
        cv.wait(lock, [&] { return data != T{}; });
        return data;
    }
};

17. Concurrent LRU Cache

#include <unordered_map>
#include <list>

class ConcurrentLRUCache {
    std::shared_mutex mutex;
    std::unordered_map<int, int> data;
    std::list<int> lruList;
    int capacity;

public:
    ConcurrentLRUCache(int capacity) : capacity(capacity) {}

    int get(int key) {