std::condition_variable

class condition_variable;

std::condition_variable — примитив синхронизации, используемый с std::mutex для блокировки одного или нескольких потоков до тех пор, пока другой поток не изменит общую переменную (условие) и не уведомит std::condition_variable.

Поток, который собирается изменить общую переменную, должен:

1. Захватить std::mutex (обычно с помощью std::lock_guard).
2. Изменить общую переменную, удерживая блокировку.
3. Вызвать notify_one или notify_all для std::condition_variable (это можно сделать после снятия блокировки).

Даже если общая переменная является атомарной, её необходимо изменить, удерживая мьютекс, чтобы корректно опубликовать изменение для ожидающего потока.

Любой поток, который собирается ожидать на std::condition_variable, должен:

1. Захватить std::unique_lock<std::mutex> для мьютекса, используемого для защиты общей переменной.
2. Выполнить одно из следующих действий:

1. Проверить условие на случай, если оно уже было обновлено и отправлено уведомление.
2. Вызвать wait, wait_for или wait_until для std::condition_variable (атомарно освобождает мьютекс и приостанавливает выполнение потока до получения уведомления от переменной условия, истечения времени ожидания или возникновения ложного пробуждения, а затем перед возвратом атомарно захватывает мьютекс).
3. Проверить условие и продолжить ожидание, если оно не выполнено.

1. Использовать перегрузку wait, wait_for и wait_until с предикатом, которая выполняет те же три шага.

std::condition_variable работает только с std::unique_lock<std::mutex>, что обеспечивает максимальную эффективность на некоторых платформах. std::condition_variable_any предоставляет переменную условия, которая работает с объектом любого типа BasicLockable, например std::shared_lock.

Переменные условия допускают одновременный вызов функций-членов wait, wait_for, wait_until, notify_one и notify_all.

Класс std::condition_variable является типом со стандартной компоновкой. Он не удовлетворяет требованиям CopyConstructible, MoveConstructible, CopyAssignable или MoveAssignable.

Вложенные типы

Функции-члены

Пример

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <string>
#include <thread>

std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;

void worker_thread()
{
    // wait until main() sends data
    std::unique_lock lk(m);
    cv.wait(lk, []{ return ready; });
    
    // after the wait, we own the lock
    std::cout << "Worker thread is processing data\n";
    data += " after processing";
    
    // send data back to main()
    processed = true;
    std::cout << "Worker thread signals data processing completed\n";
    
    // manual unlocking is done before notifying, to avoid waking up
    // the waiting thread only to block again (see notify_one for details)
    lk.unlock();
    cv.notify_one();
}

int main()
{
    std::thread worker(worker_thread);
    
    data = "Example data";
    // send data to the worker thread
    {
        std::lock_guard lk(m);
        ready = true;
        std::cout << "main() signals data ready for processing\n";
    }
    cv.notify_one();
    
    // wait for the worker
    {
        std::unique_lock lk(m);
        cv.wait(lk, []{ return processed; });
    }
    std::cout << "Back in main(), data = " << data << '\n';
    
    worker.join();
}

main() signals data ready for processing
Worker thread is processing data
Worker thread signals data processing completed
Back in main(), data = Example data after processing

См. также