Production-grade thread-safe data structures and coordination implementations.

1. Print Odd and Even (Two Threads)

2. Bounded Blocking Queue

Thread-safe blocking queue using a circular array, a mutex, and two condition variables:

#include <vector>
#include <mutex>
#include <condition_variable>

class BoundedBlockingQueue {
private:
std::vector<int> queue;
int capacity;
int head = 0;
int tail = 0;
int size = 0;
std::mutex mtx;
std::condition_variable not_full;
std::condition_variable not_empty;

public:
BoundedBlockingQueue(int cap) : capacity(cap), queue(cap) {}

void enqueue(int element) {
std::unique_lock<std::mutex> lock(mtx);
not_full.wait(lock, [this]() { return size < capacity; });

queue[tail] = element;
tail = (tail + 1) % capacity;
size++;

not_empty.notify_one();
}

int dequeue() {
std::unique_lock<std::mutex> lock(mtx);
not_empty.wait(lock, [this]() { return size > 0; });

int val = queue[head];
head = (head + 1) % capacity;
size--;

not_full.notify_one();
return val;
}
};

3. Thread-Safe Counter (Atomic & CAS)

4. Read-Write Lock Implementation

Implementing a custom Readers-Writer Lock with priority prevention using mutexes and condition variables:

#include <mutex>
#include <condition_variable>

class RWLock {
private:
std::mutex mtx;
std::condition_variable cv;
int readers = 0;
bool writer_active = false;
int waiting_writers = 0; // Prevent reader starvation

public:
void lockRead() {
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, [this]() { return !writer_active && waiting_writers == 0; });
readers++;
}

void unlockRead() {
std::unique_lock<std::mutex> lock(mtx);
readers--;
if (readers == 0) {
cv.notify_all();
}
}

void lockWrite() {
std::unique_lock<std::mutex> lock(mtx);
waiting_writers++;
cv.wait(lock, [this]() { return !writer_active && readers == 0; });
waiting_writers--;
writer_active = true;
}

void unlockWrite() {
std::unique_lock<std::mutex> lock(mtx);
writer_active = false;
cv.notify_all();
}
};