std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, []{return !queue.empty();});

    {
        std::lock_guard<std::mutex> lk(cv_m);
        queue.push(xyz);
    }
    cv.notify_all();

• edge-triggered
  
• level-triggered

class thread_event
{
public:
    explicit thread_event(bool initial_state = false);

    bool get() const;
    void reset();
    void signal(); // wake up all waiting threads

    void wait();
    bool wait(int timeout_millisecs); // false - timeout expired

private:
    std::condition_variable m_cv;
    mutable std::mutex m_mtx;
    bool m_state;

    thread_event(const thread_event&) = delete;
    thread_event& operator=(const thread_event&) = delete;
};

thread_event::thread_event(bool initial_state /*= false*/):
    m_state(initial_state)
{
}

bool thread_event::get() const
{
    std::lock_guard<std::mutex> lock(m_mtx);
    return m_state;
}

void thread_event::reset()
{
    std::lock_guard<std::mutex> lock(m_mtx);
    m_state = false;
}

void thread_event::signal()
{
    std::lock_guard<std::mutex> lock(m_mtx);
    m_state = true;
    m_cv.notify_all();
}

void thread_event::wait()
{
    std::unique_lock<std::mutex> lock(m_mtx);
    m_cv.wait(lock, [this]() { return m_state; });
}

bool thread_event::wait(int timeout_millisecs)
{
    std::unique_lock<std::mutex> lock(m_mtx);
    return m_cv.wait_for(lock, std::chrono::milliseconds(timeout_millisecs), [this]() { return m_state; });
}

thread 1                                    |  thread 2
                                            | 
if ( thread_event::get() )                  | 
                                            |   thread_event::signal();
  thread_event::reset();                    |
thread_event::wait();  <--- signal потерен  |

Q>class thread_event
Q>{
Q>public:
Q>    explicit thread_event(bool initial_state = false);

Q>    bool get() const;
Q>    void reset();
Q>    void signal(); // wake up all waiting threads

Q>    void wait();
Q>    bool wait(int timeout_millisecs); // false - timeout expired

Q>private:
Q>    std::condition_variable m_cv;
Q>    mutable std::mutex m_mtx;
Q>    bool m_state;

Q>    thread_event(const thread_event&) = delete;
Q>    thread_event& operator=(const thread_event&) = delete;
Q>};

Q>thread_event::thread_event(bool initial_state /*= false*/):
Q>    m_state(initial_state)
Q>{
Q>}

Q>bool thread_event::get() const
Q>{
Q>    std::lock_guard<std::mutex> lock(m_mtx);
Q>    return m_state;
Q>}

Q>void thread_event::reset()
Q>{
Q>    std::lock_guard<std::mutex> lock(m_mtx);
Q>    m_state = false;
Q>}

Q>void thread_event::signal()
Q>{
Q>    std::lock_guard<std::mutex> lock(m_mtx);
Q>    m_state = true;
Q>    m_cv.notify_all();
Q>}

Q>void thread_event::wait()
Q>{
Q>    std::unique_lock<std::mutex> lock(m_mtx);
Q>    m_cv.wait(lock, [this]() { return m_state; });
Q>}

Q>bool thread_event::wait(int timeout_millisecs)
Q>{
Q>    std::unique_lock<std::mutex> lock(m_mtx);
Q>    return m_cv.wait_for(lock, std::chrono::milliseconds(timeout_millisecs), [this]() { return m_state; });
Q>}
Q>

index thread                 | search thread 1            | search thread 2            
-----------------------------|----------------------------|--------------------------------
ev.reset() // no valid index |                            |   
                             | ev.wait() // not ready yet | 
// build full text index...  |                            |
                             |                            |
ev.signal() // ready         | // wake up                 |
                             |                            | ev.wait() // pass through

assert(ev1.get() && ev2.get() && !ev3.get());