std::condition_variable 虚假阻塞

Question

如您所知，应循环调用条件变量以避免虚假唤醒。像这样：

while (not condition)
    condvar.wait();

如果另一个线程想要唤醒等待线程，它必须设置条件标志为真。例如：

condition = true;
condvar.notify_one();

我想知道，条件变量是否可能被这种情况阻止：

1)等待线程检查条件标志，发现它等于FALSE，所以进入condvar.wait()例程。

2）但在此之前（但在条件标志检查之后）等待线程被内核抢占（例如，由于时隙到期）。

3) 这时，另一个线程想要通知等待线程的条件。它将条件标志设置为 TRUE 并调用 condvar.notify_one();

4) 当内核调度器再次运行第一个线程时，它进入condvar.wait() 例程，但已经错过了通知。

因此，尽管条件标志设置为 TRUE，但等待线程无法从 condvar.wait() 退出，因为不再有唤醒通知。

有可能吗？

Answer 1

这正是条件变量必须与互斥锁结合使用的原因，以便自动更新状态并发出更改信号。完整的代码看起来更像：

unique_lock<mutex> lock(mutex);
while (not condition)
    condvar.wait(lock);

对于另一个线程：

lock_guard<mutex> lock(mutex);
condition = true;
condvar.notify_one();

Answer 2

你的例子遗漏了一小部分，但这解释了为什么如果做得正确是不可能的：

while (not condition) // when you check condition mutex is locked
    condvar.wait( mutex ); // when you wait mutex is unlocked

所以如果在同一个互斥锁下将condition改为true，就不会出现这种情况了。

Answer 3

Mike Seymour 他的回答是不完整的，因为有一个竞争条件最终导致唤醒丢失。 正确的方法是（现在用c++11）如下：

线程1：

std::unique_lock<std::mutex> lck(myMutex);
condvar.wait(lck, []{ return condition; }); // prevent spurious wakeup
// Process data

线程2：

{
    std::lock_guard<std::mutex> lck(myMutex);
    condition = true;
} // unlock here! prevent wakeup lost
condvar.notify_one();

Answer 4

是的（我在 2012 年 12 月对此进行了测试），而且我不久前想出了一个解决方案。 “耀斑”类： 请注意，它使用自旋锁，但在此花费的时间很少。

声明（hpp）：

class Flare
{
public:
/**
\brief Flare's constructor.
\param fall_through_first, will skip the first wait() if true.
*/
Flare(bool fall_through_first = false);


/**
\brief Flare's destructor.

Takes care of removing the object of this class.
*/
~Flare();


/**
\brief Notifies the same object of availability.

Any thread waiting on this object will be freed,
and if the thread was not waiting, it will skip
wait when it iterates over it.
*/
void notify();


/**
\brief Wait until the next notification.

If a notification was sent whilst not being
inside wait, then wait will simply be skipped.
*/
void wait();


private:
    std::mutex m_mx; // Used in the unique_lock,
    std::unique_lock<std::mutex> m_lk; // Used in the cnd_var
    std::condition_variable m_cndvar;

    std::mutex m_in_function, n_mx; // protection of re-iteration.
    bool m_notifications;

};

实施/定义 (cpp)：

#include "Flare.hpp"


// PUBLIC:

Flare::Flare(bool fall_through_first)
:
m_lk(m_mx),
m_notifications(!fall_through_first)
{}

Flare::~Flare()
{}

void Flare::notify()
{
    if (m_in_function.try_lock() == true)
    {
        m_notifications = false;
        m_in_function.unlock();
    }
    else // Function is waiting.
    {
        n_mx.lock();
        do
        {
            m_notifications = false;
            m_cndvar.notify_one();
        }
        while (m_in_function.try_lock() == false);
        n_mx.unlock();
        m_in_function.unlock();
    }
}

void Flare::wait()
{
    m_in_function.lock();
    while (m_notifications)
        m_cndvar.wait(m_lk);
    m_in_function.unlock();
    n_mx.lock();
    m_notifications = true;
    n_mx.unlock();
}