为什么 condition_variable 在等待生产者-消费者的锁？ C++

Question

看下面这段经典的生产者消费者代码：

int main()
{
    std::queue<int> produced_nums;
    std::mutex m;
    std::condition_variable cond_var;
    bool done = false;
    bool notified = false;

    std::thread producer([&]() {
        for (int i = 0; i < 5; ++i) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::unique_lock<std::mutex> lock(m);
            std::cout << "producing " << i << '\n';
            produced_nums.push(i);
            notified = true;
            cond_var.notify_one();
        }

        done = true;
        cond_var.notify_one();
    });

    std::thread consumer([&]() {
        std::unique_lock<std::mutex> lock(m);
        while (!done) {
            while (!notified) {  // loop to avoid spurious wakeups
                cond_var.wait(lock);
            }
            while (!produced_nums.empty()) {
                std::cout << "consuming " << produced_nums.front() << '\n';
                produced_nums.pop();
            }
            notified = false;
        }
    });

    producer.join();
    consumer.join();
}

我从 cppreference 复制了这个。

一切对我来说都非常简单，除了消费者中的行：

cond_var.wait(lock);

我明白等待cond_var通知的循环，但为什么要等待锁？

Answer 1

cond_var.wait(lock);不等待锁。该行做了 3 件事

它解锁 lock 变量
它一直等到有人发出条件信号。
它在 returns,

lock

它以原子方式完成这一切。当线程正在等待条件变量时，互斥量不会被锁定——这样你的生产者线程就可以获得锁并安全地设置 consumers/producer 之间共享的任何变量。

它在 return 时再次锁定互斥量，因此使用者可以再次安全地访问共享变量。

如果您尝试自己管理 locking/unlocking 互斥锁，您最终会在 locking/unlocking 互斥锁和 waiting/signalling 条件变量之间出现竞争条件 - 这就是等待条件变量绑定到互斥体 - 因此它可以自动完成，没有竞争条件。

为什么 condition_variable 在等待生产者-消费者的锁？ C++

Why condition_variable is waiting for the lock in producer-consumer? C++

c++

concurrency

locking

producer-consumer

c++11