仅当有等待线程时才notify_one是否正确？

Question

我已经多次看到以下类型的调度队列实现，其中将新元素推送到队列的线程仅在推送元素之前队列为空时才调用notify_one。这种情况会减少不必要的notify_one调用，因为在推送新元素之前q.size() != 0意味着只有活动线程（假设有多个消费者线程）。

#include <queue>
#include <condition_variable>
#include <mutex>

using Item = int;
std::queue<Item> q;
std::condition_variable cv;
std::mutex m;

void process(Item i){}

void pop() {
  while (true) {
    std::unique_lock<std::mutex> lock(m);
    // This thread releases the lock and start waiting.
    // When notified, the thread start trying to re-acquire the lock and exit wait().
    // During the attempt (and thus before `pop()`), can another `push()` call acquire the lock? 
    cv.wait(lock, [&]{return !q.empty();});
    auto item = q.front();
    q.pop();
    process(item);
  }
}

void push(Item i) {
  std::lock_guard<std::mutex> lock(m);
  q.push(i);
  if (q.size() == 1) cv.notify_one();
}

int main() { /* ... */ }

但是，以下情况可能吗？假设所有消费者线程都在等待。

1. 推送线程获取锁并推送新元素并调用notify_one，因为队列为空。
2. 被通知的线程尝试重新获取锁（并退出 wait()），
3. 推送线程再次获取锁并在被通知的线程重新获取锁之前推送另一个元素。

在这种情况下，3.之后就不会发生notify_one调用，并且当队列不为空时，只有一个活动线程。

Answer 1

对于唤醒后的操作

根据wake's doc

1. 以原子方式解锁锁，阻塞当前正在执行的线程，并将其添加到等待 *this 的线程列表中。当执行notify_all()或notify_one()时，线程将被解除阻塞。也可能被虚假解锁。解锁后，无论何种原因，重新获取锁定并等待退出。

意味着您的代码在唤醒时在 #1 到 #2 之间是原子的。无需担心同步，因为您的编译器应该处理它。

void pop() {
  while (true) {
    std::unique_lock<std::mutex> lock(m);

    // When sleep, cv release the lock
    cv.wait(lock, [&]{return !q.empty();});   // <----#1
    // When wake up, it acquires the lock
    auto item = q.front();
    q.pop();
    process(item);                            // <----#2
  }
}

对于虚假唤醒

第二个谓词重载将为您处理虚假唤醒。
模板<类谓词> void wait( std::unique_lock& 锁，谓词 stop_waiting ); (2) (C++11 起)

相当于

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

此重载可用于在等待特定条件成立时忽略虚假唤醒。

注意，进入该方法之前必须获取锁，并且在 wait(lock) 退出后重新获取锁，这意味着锁可以用来保护对 stop_waiting() 的访问。

这就是带有谓词的 condition_variable 重载可以让您避免虚假唤醒。
不需要用于检查虚假唤醒的手工 while 循环。