Синхронизация потоков. std::condition_variable.

как-то все сумбурно.

вот у тебя 2 очереди:
Поток заполняет очередь, свопает ее со второй и делает нотификацию
Второй поток просыпается, обрабатывает очередь и ждет снова
так?

Не две очереди, двойная буферизация.
Первый поток заполняет буфер по указателю P, который указывает на буфер A. Как только заполнил, он выставляет указатель P2 на буфер A, делает нотификацию и меняет указатель P, теперь он указывает на буфер B.
Второй поток просыпается по нотификации и обрабатывает буфер по указателю P2.
Нужно, чтобы второй поток игнорировал пропущенные нотификации и ждал те, которые произойдут уже после того, как он заснул.

Нужно, чтобы второй поток игнорировал пропущенные нотификации и ждал те, которые произойдут уже после того, как он заснул.

Так оно и будет. Если CV не ждет, то оно пропустит нотификации. Сработать может по предикату. Если тебе не хватает в предикате флажка ready, добавь туда еще условие. например непустая очередь.

Так оно и будет. Если CV не ждет, то оно пропустит нотификации.

Разве? Вот я изменил пример по ссылке:

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

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<std::mutex> 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()
{
    data = "Example data";
    // send data to the worker thread
    {
        std::lock_guard<std::mutex> lk(m);
        ready = true;
        std::cout << "main() signals data ready for processing\n";
    }
    cv.notify_one(); ////// Сначала нотификация

    std::thread worker(worker_thread); ////// Потом создание треда

    // wait for the worker
    {
        std::unique_lock<std::mutex> 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

Worker thread is processing data

Если ожидание сделать вот таким «cv.wait(lk);», т.е. без предиката, то worker_thread() не просыпается. Значит он пропускает нотификацию. И, вроде как, проблема решена.

Но! Везде пишут, что обязательно ещё какое-то условие проверять, т.к. бывают ложные пробуждения (spurious wakeup).

Как это решить просто и красиво?

в гугле забанили ?
http://f0b0s.blogspot.com/2013/04/spurious-wakeup.html

в гугле забанили ?

Это я читал, про spurious wakeup сам писал. Вопрос не в этом, а как игнорировать пропущенные notify_one().

доп условиями и флажками по вашему коду

доп условиями и флажками по вашему коду

Можно пример? Хочется не городить миллион костылей, но пока простое решение в голову не приходит.

пример чего ? это логика вашего кода. вам видней как ее предвидеть

Ставь первым потоком перед нотификацией флаг, который второй поток будет сбрасывать перед засыпанием.

Смотри строчку 15 из примера, читай доку, думай мысли, люби гусей.

Ставь первым потоком перед нотификацией флаг

Понятно. Соответственно и проверять флаг перед нотификацией. Если ещё поднят, значит нотификацию не делать.
Вопрос в том, где это правильно делать? Внутри вот этого блока (из примера):

{
  std::lock_guard<std::mutex> lk(m);
  ready = true;
  std::cout << "main() signals data ready for processing\n";
}

Соответственно, cv.notify_one() внести внутрь блока с lock_guard?

Вообще не принципиально, гонки тут не будет.

Вообще не принципиально, гонки тут не будет.

Хорошо, спасибо.
Не совсем понял, когда же происходят эти spurious wakeup.
Можно специально словить?

откуда ж вам понять если вы нихрена из гугла и ссылок здесь не читали, хотя заявили что читали

>>в гугле забанили ?

>Это я читал, про spurious wakeup сам писал

Можно даже без флага, сделать разделяемый указатель на данные, когда второй поток забирает пакет на обработку - он обнуляет указатель (под защитой mutex), когда первый поток подготовил данные - выставляет указатель (под защитой mutex), и будит второго через condition_variable, связанный с тем же mutex.

Во-первых очереди нет и указатель (лучше умный, unique_ptr) всегда хранит актуальный пакет либо равен nullptr.

Во-вторых борьба с suspicious wakeup упрощается - надо просто проверить указатель.