# shared\_mutex

***

**1. Reader-Writer Lock**

```cpp
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**

```cpp
#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**

```cpp
#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**

```cpp
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**

```cpp
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**

```cpp
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**

```cpp
#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**

```cpp
#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**

```cpp
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**

```cpp
#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**

```cpp
#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**

```cpp
#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**

```cpp
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**

```cpp
#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**

```cpp
#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**

```cpp
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**

```cpp
#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) {

```