使用带有std :: condition_variable_any的伪造假锁是否安全？

Question

我正在寻找的是类似Linux内核中的wait_queue_t的东西。 我与同步相关的基础数据结构是无锁的，因此不需要保护互斥体。

仅仅为了能够使用std::condition_variable来阻塞等待而必须获取std::mutex似乎会引入不必要的开销。

我知道Linux有futex ，Windows有WaitOnAddress ，但是我对这里的语言标准更感兴趣。

根据cppreference维基， std::condition_variable_any可以与任何自定义Lockable 。

那么，如果我将其与伪造的伪锁一起使用，如下所示：

class FakeLock
{
public:
    inline void lock() {}
    inline void unlock() {}
    inline bool try_lock() { return true; }
};

template<typename WaitLock=FakeLock>
class WaitQueue
{
private:
    WaitLock m_lock;
    std::condition_variable_any m_cond;

public:
    inline void wait()
    {   
        std::unique_lock<WaitLock> lock(m_lock);

        m_cond.wait(lock);
    }   

    inline void notify_one()
    {   
        m_cond.notify_one();
    }   

    inline void notify_all()
    {   
        m_cond.notify_all();
    }   
};

以使用Linux内核wait_queue_t的方式使用上面的WaitQueue是否有意外行为的潜在风险？

Answer 1

再次考虑这个问题，我想我得到了答案。

给定一个LockFreeStack类，它是一个无锁堆栈。

考虑以下代码：

WaitQueue wq;
LockFreeStack<std::string> stack;

std::thread t1([&]() {
    while (true) {
         // sleep for some time
         stack.push(/* random string */);          // (1.1)
         wq.notify_one();                          // (1.2)
    }
});

std::thread t2([&]() {
    while (true) {
         if (stack.empty())                        // (2.1)
             wq.wait();                            // (2.2)
         auto str = stack.pop();
         // print string
    }
});

如果不使用实锁来保护wait_queue /条件变量，则两个线程可以按以下顺序执行：

(2.1)
(1.1)
(1.2)
(2.2)

使线程t2完全错过了t1的最新更新。 t2将仅在下一次notify_one()调用后才能恢复执行。

真正的锁是必需的，以确保条件变量可以随实际的实际数据/状态自动更改。