Concurrency Coding Problems

import threading
from collections import deque

class BoundedBuffer:
    def __init__(self, capacity):
        self.buf = deque()
        self.cap = capacity
        self.lock = threading.Lock()
        self.not_full = threading.Condition(self.lock)
        self.not_empty = threading.Condition(self.lock)

    def put(self, item):
        with self.not_full:
            while len(self.buf) == self.cap:   # while, not if — guard against spurious wakeups
                self.not_full.wait()
            self.buf.append(item)
            self.not_empty.notify()            # wake one waiting consumer

    def get(self):
        with self.not_empty:
            while not self.buf:
                self.not_empty.wait()
            item = self.buf.popleft()
            self.not_full.notify()
            return item

// Java — Producer-Consumer (Bounded Buffer)
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedBuffer<T> {
    private final Queue<T> queue = new LinkedList<>();
    private final int capacity;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public BoundedBuffer(int capacity) {
        this.capacity = capacity;
    }

    public void put(T item) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) { // while loop guards against spurious wakeups
                notFull.await();
            }
            queue.add(item);
            notEmpty.signal(); // wake one waiting consumer
        } finally {
            lock.unlock();
        }
    }

    public T get() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            T item = queue.poll();
            notFull.signal(); // wake one waiting producer
            return item;
        } finally {
            lock.unlock();
        }
    }
}

// C++ — Producer-Consumer (Bounded Buffer)
#include <queue>
#include <mutex>
#include <condition_variable>

template <typename T>
class BoundedBuffer {
private:
    std::queue<T> queue;
    size_t capacity;
    std::mutex mtx;
    std::condition_variable not_full;
    std::condition_variable not_empty;

public:
    BoundedBuffer(size_t cap) : capacity(cap) {}

    void put(T item) {
        std::unique_lock<std::mutex> lock(mtx);
        // while loop guards against spurious wakeups
        not_full.wait(lock, [this]() { return queue.size() < capacity; });
        queue.push(item);
        not_empty.notify_one();
    }

    T get() {
        std::unique_lock<std::mutex> lock(mtx);
        not_empty.wait(lock, [this]() { return !queue.empty(); });
        T item = queue.front();
        queue.pop();
        not_full.notify_one();
        return item;
    }
};

// Java — Print in Order using Semaphores
import java.util.concurrent.Semaphore;

class Foo {
    private final Semaphore s2 = new Semaphore(0);
    private final Semaphore s3 = new Semaphore(0);

    public Foo() {}

    public void first(Runnable printFirst) throws InterruptedException {
        printFirst.run();
        s2.release();
    }

    public void second(Runnable printSecond) throws InterruptedException {
        s2.acquire();
        printSecond.run();
        s3.release();
    }

    public void third(Runnable printThird) throws InterruptedException {
        s3.acquire();
        printThird.run();
    }
}

// C++ — Print in Order using Condition Variables
#include <mutex>
#include <condition_variable>
#include <functional>

class Foo {
private:
    std::mutex mtx;
    std::condition_variable cv;
    int step = 1;

public:
    Foo() {}

    void first(std::function<void()> printFirst) {
        std::unique_lock<std::mutex> lock(mtx);
        printFirst();
        step = 2;
        cv.notify_all();
    }

    void second(std::function<void()> printSecond) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this]() { return step == 2; });
        printSecond();
        step = 3;
        cv.notify_all();
    }

    void third(std::function<void()> printThird) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [this]() { return step == 3; });
        printThird();
    }
};