如何确保在notify_one之前调用wait_for

Question

条件变量的典型用法如下所示（请参阅下面的代码）：http://en.cppreference.com/w/cpp/thread/condition_variable。

但是，似乎主线程可能会在工作线程调用wait之前调用notify_one，这会导致死锁。我错了吗？如果不是，那么通常的解决方法是什么？

#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() 
{ 
    std::thread worker(worker_thread); 

    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(); 

    // 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(); 
} 

Answer 1

注意使用条件（你应该永远使用唯一的等待）的definition of wait：

while (!pred()) { 
    wait(lock); 
} 

如果通知已经被解雇就意味着病情已经成为事实（这是notify_one之前测序在信号线程中）。所以当接收者使用互斥锁并查看pred（）时，它将是真实的，它将继续。