60

我发现std::condition_variable由于虚假唤醒，它很难使用。所以有时我需要设置一个标志，例如：

atomic<bool> is_ready;

我在调用通知（或）之前设置is_ready为，然后等待：truenotify_one()notify_all()

some_condition_variable.wait(some_unique_lock, [&is_ready]{
    return bool(is_ready);
});

有什么理由我不应该这样做：（编辑：好的，这真是个坏主意。）

while(!is_ready) {
    this_thread::wait_for(some_duration); //Edit: changed from this_thread::yield();
}

如果condition_variable选择了等待时间（我不知道这是不是真的），我更喜欢自己选择。

4

2 回答 2

98

您可以通过以下任何一种方式进行编码：

  1. 使用原子和轮询循环。
  2. 使用condition_variable.

我已经在下面为您编码了两种方式。在我的系统上，我可以实时监控任何给定进程正在使用多少 CPU。

首先是轮询循环：

#include <atomic>
#include <chrono>
#include <iostream>
#include <thread>

std::atomic<bool> is_ready(false);

void
test()
{
    std::this_thread::sleep_for(std::chrono::seconds(30));
    is_ready.store(true);
}

int
main()
{
    std::thread t(test);
    while (!is_ready.load())
        std::this_thread::yield();
    t.join();
}

对我来说，这需要 30 秒来执行，而在执行过程中需要大约 99.6% 的 cpu。

或者使用condition_variable：

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>

bool is_ready(false);
std::mutex m;
std::condition_variable cv;

void
test()
{
    std::this_thread::sleep_for(std::chrono::seconds(30));
    std::unique_lock<std::mutex> lk(m);
    is_ready = true;
    cv.notify_one();
}

int
main()
{
    std::thread t(test);
    std::unique_lock<std::mutex> lk(m);
    while (!is_ready)
    {
        cv.wait(lk);
        if (!is_ready)
            std::cout << "Spurious wake up!\n";
    }
    t.join();
}

这具有完全相同的行为，只是在 30 秒执行期间，该进程占用 0.0% cpu。如果您正在编写一个可以在电池供电的设备上执行的应用程序，那么后者在电池上几乎是无限容易的。

现在诚然，如果您的 实现非常糟糕std::condition_variable，它可能与轮询循环一样低效。然而在实践中，这样的供应商应该很快就会倒闭。

更新

为了咧嘴笑，我用一个虚假的唤醒检测器增加了我的 condition_variable 等待循环。我再次运行它，它没有打印出任何东西。没有一个虚假的唤醒。这当然不能保证。但它确实证明了高质量的实施可以实现什么。

于 2013-05-03T02:21:16.760 回答
34

的目的std::condition_variable是等待某个条件变为真。它的设计目的不仅仅是通知的接收者。例如，当消费者线程需要等待队列变为非空时，您可能会使用它。

T get_from_queue() {
   std::unique_lock l(the_mutex);
   while (the_queue.empty()) {
     the_condition_variable.wait(l);
   }
   // the above loop is _exactly_ equivalent to the_condition_variable.wait(l, [&the_queue](){ return !the_queue.empty(); }
   // now we have the mutex and the invariant (that the_queue be non-empty) is true
   T retval = the_queue.top();
   the_queue.pop();
   return retval;
}

put_in_queue(T& v) {
  std::unique_lock l(the_mutex);
  the_queue.push(v);
  the_condition_variable.notify_one();  // the queue is non-empty now, so wake up one of the blocked consumers (if there is one) so they can retest.
}

消费者 ( get_from_queue)不是在等待条件变量，而是在等待条件the_queue.empty()。条件变量为您提供了在它们等待时让它们进入睡眠状态的方法，同时释放互斥锁并以一种避免您错过唤醒的竞争条件的方式这样做。

您正在等待的条件应该受到互斥锁的保护（当您等待条件变量时释放的那个）。这意味着条件很少（如果有的话）需要是一个atomic. 您总是从互斥锁中访问它。

于 2013-05-03T02:20:14.010 回答