wait_until 在主线程中的工作方式与主线程不同吗？ C++

Question

在一个单独的主线程中执行相同的代码，条件变量的行为不同

#include <iostream>
#include <condition_variable>
#include <mutex>
#include <chrono>
#include <thread>
using namespace std;
using namespace std::chrono;
using namespace std::chrono_literals;
void waits()
{
    std::mutex mCvMtx;
    std::condition_variable mCondVar;

   auto now = std::chrono::system_clock::now();

    std::unique_lock<std::mutex> lk(mCvMtx);
    if(mCondVar.wait_until(lk, now+ 3*1000ms) ==  cv_status::timeout)
    {
        cout << "Fire";
    }
    else
    {
        cout << "Condition variable notified ";
    }
    now = std::chrono::system_clock::now();
}

int main()
{

     std::thread t1(waits);
     t1.join(); 

    return 0;
}

#include <iostream>
#include <condition_variable>
#include <mutex>
#include <chrono>
#include <thread>
using namespace std;
using namespace std::chrono;
using namespace std::chrono_literals;

int main()
{
     std::mutex mCvMtx;
    std::condition_variable mCondVar;

   auto now = std::chrono::system_clock::now();

    std::unique_lock<std::mutex> lk(mCvMtx);
    if(mCondVar.wait_until(lk, now+ 3*1000ms) ==  cv_status::timeout)
    {
        cout << "Fire";
    }
    else
    {
        cout << "Condition variable notified ";
    }
    now = std::chrono::system_clock::now();

    return 0;
}

我不明白为什么在第一个示例中输出结果为“Fire”（因此未通知 cv 并等待我指定的时间），而在第二个示例中，我在主线程中执行相同的代码，输出结果“通知条件变量”，无需等待任何秒。

你有什么解释吗？谢谢

Answer 1

因为spurious wakeups

虚假唤醒描述了使用条件的复杂性 某些多线程 API（例如 POSIX）提供的变量 线程和 Windows API。

即使在条件变量似乎已从 等待线程的观点，等待的条件可能 还是假的。造成这种情况的原因之一是虚假唤醒。那 也就是说，一个线程可能会从它的等待状态中被唤醒，即使没有 线程向条件变量发出信号。为了正确，它是 那么，有必要在 线程已完成等待。因为可能会发生虚假唤醒 重复地，这是通过在一个终止的循环内等待来实现的 当条件为真时

进一步阅读：

C++ Core Guidelines: Be Aware of the Traps of Condition Variables

Answer 2

条件变量只是一种没有状态的通知机制，因此在没有服务员时通知会丢失，而在没有发出通知时虚假唤醒会解除阻塞。

您必须等待共享状态发生变化。例如：

std::mutex m;
std::condition_variable c;

// Only ever read or write shared_state when the mutex is locked.
// Otherwise race conditions create a deadlock.
bool shared_state = false;

// Waiting thread.
void wait() {
    std::unique_lock<std::mutex> l(m);
    while(!shared_state) // Also handles spurious wake ups.
        c.wait(l);
    // shared_state is true, mutex is locked.
}

// Notifying thread.
void wait() {
    {
        std::unique_lock<std::mutex> l(m);
        shared_state = true;
    }
    c.notify_one();
}