std::mutex + std::condition_variable

std::mutex — примитив взаимного исключения: lock()/unlock() гарантируют, что только один поток одновременно находится в критической секции. std::condition_variable — примитив ожидания: поток блокируется на wait(), пока другой поток не вызовет notify_one()/notify_all(), освобождая mutex на время сна и захватывая его обратно перед возвратом из wait.std::mutex is a mutual-exclusion primitive: lock()/unlock() guarantee that only one thread is in the critical section at a time. std::condition_variable is a waiting primitive: a thread blocks on wait() until another thread calls notify_one()/notify_all(), releasing the mutex while asleep and reacquiring it before returning from wait.

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  cv = PTHREAD_COND_INITIALIZER;
pthread_mutex_lock(&m);
while (!ready) pthread_cond_wait(&cv, &m);
pthread_mutex_unlock(&m);

std::mutex m;
std::condition_variable cv;
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, [] { return ready; });   // предикат защищает// the predicate guards
                                       // от spurious wakeup// against spurious wakeup

Как и std::thread, эти примитивы закрывают разрыв между потребностью и отсутствием стандартного решения:Like std::thread, these primitives close the gap between an existing need and the lack of a standard solution:

На Linux std::mutex обычно реализован через futex (fast userspace mutex) — быстрый путь без syscall при отсутствии contention, с падением в syscall (блокировка потока планировщиком) только когда мьютекс уже занят. Полный разбор паттерна producer/consumer через mutex + condition_variable (включая обязательность предиката в wait против spurious wakeups) — в cpp_concurrency.md, здесь — происхождение и минимальный пример.On Linux, std::mutex is typically implemented via a futex (fast userspace mutex) — a fast path with no syscall when there's no contention, falling back to a syscall (the scheduler blocking the thread) only when the mutex is already held. A full breakdown of the producer/consumer pattern using mutex + condition_variable (including why a predicate in wait is mandatory against spurious wakeups) lives in cpp_concurrency.md — here it's just the origin and a minimal example.

#include <mutex>
#include <condition_variable>
#include <queue>

std::mutex m;
std::condition_variable cv;
std::queue<int> q;

void producer() {
    {
        std::lock_guard<std::mutex> lk(m);
        q.push(42);
    }                      // lock_guard освобождает mutex здесь// lock_guard releases the mutex here
    cv.notify_one();       // будить можно и вне лока// notifying outside the lock is fine too
}

void consumer() {
    std::unique_lock<std::mutex> lk(m);   // unique_lock, не lock_guard —// unique_lock, not lock_guard —
                                            // нужен для wait()// needed for wait()
    cv.wait(lk, [] { return !q.empty(); }); // предикат обязателен// the predicate is mandatory
    int v = q.front(); q.pop();
}

Не «реализация фичи», а типовое практическое задание, которое собирается именно из mutex + condition_variable: потокобезопасная очередь с ограниченной ёмкостью, блокирующая producer при заполнении и consumer при опустошении.Not a "feature implementation" but a typical practical exercise built exactly out of mutex + condition_variable: a thread-safe queue with bounded capacity that blocks the producer when full and the consumer when empty.

bounded_queue.hpp

template <class T>
class BoundedQueue {
    std::mutex m_;
    std::condition_variable not_full_, not_empty_;
    std::deque<T> q_;
    size_t cap_;
public:
    explicit BoundedQueue(size_t cap) : cap_(cap) {}

    void push(T v) {
        std::unique_lock<std::mutex> lk(m_);
        not_full_.wait(lk, [&] { return q_.size() < cap_; }); // предикат обязателен// the predicate is mandatory
        q_.push_back(std::move(v));
        lk.unlock();           // можно уведомить вне лока// notifying outside the lock is fine
        not_empty_.notify_one();
    }

    T pop() {
        std::unique_lock<std::mutex> lk(m_);
        not_empty_.wait(lk, [&] { return !q_.empty(); });
        T v = std::move(q_.front());
        q_.pop_front();
        lk.unlock();
        not_full_.notify_one();
        return v;
    }
};

Логичное развитие того же задания — thread pool: N воркеров в цикле вызывают pop() на общей BoundedQueue задач (обычно std::function<void()>), а push() используется для постановки задачи в очередь; завершение пула — специальный «poison pill» объект или отдельный atomic-флаг остановки, который воркеры проверяют в предикате wait. Полный разбор паттерна — в cpp_concurrency.md.The logical next step from the same exercise is a thread pool: N workers loop calling pop() on a shared BoundedQueue of tasks (usually std::function<void()>), while push() enqueues work; shutting the pool down uses a special "poison pill" object or a separate atomic stop flag that workers check in the wait predicate. A full breakdown of the pattern lives in cpp_concurrency.md.

• cppreference — std::mutex
• cppreference — std::condition_variable
• WG21 N2497 — Multi-threading Library for Standard C++