std：：condition\u变量：：notify\u one：如果某些线程具有假谓词，它是否会唤醒多个线程？

Question

我有一个用于读写器的环形缓冲区。我跟踪环形缓冲区中的数字if条目，不允许覆盖尚未读取的条目。我使用std：：condition\u variable wait（）和notify\u one（）来同步读写器。读卡器的基本条件是

这一切似乎都奏效了，但有一件事我不明白。当读写器调用notify\u one（）时，不会导致上下文切换。我读过并理解它是这样工作的。然而，在写入程序写入一个条目以填充缓冲区的情况下，写入程序html" target="_blank">调用notify\u one（）并继续写入另一个条目，在这种情况下，其谓词在其wait（）中失败。在本例中，我看到另一个writer（）可能会被唤醒，其谓词也会失败。然后，读取器将醒来，其谓词成功，并可以开始阅读。

我不明白的是，为什么一个notify_one（）上有多个线程被解锁。谓词失败的wait（）是否不会耗尽notify？我找不到任何说明这是事实的东西。

我可以调用notify\u all（）来确定，但它似乎正在使用notify\u one（）。

这是代码。

#include <iostream>
#include <stdint.h>

#include <boost/circular_buffer.hpp>
#include <condition_variable>
#include <thread>


// ring buffer with protection for overwrites 
template <typename T>
class ring_buffer {

  public:

    ring_buffer(size_t size) {
        cb.set_capacity(size);
    }

    void read(T& entry) {
        {
            std::unique_lock<std::mutex> lk(cv_mutex);
            cv.wait(lk, [this] {
                    std::cout << "read woke up, test=" << (cb.size() > 0) << std::endl; 
                    return 0 < cb.size();});
            auto iter = cb.begin();
            entry = *iter;
            cb.pop_front(); 
            std::cout << "Read notify_one" << std::endl;
        }
        cv.notify_one();
    } 

    void write(const T& entry) {
        {
            std::unique_lock<std::mutex> lk(cv_mutex);
            //std::cout << "Write wait" << std::endl;
            cv.wait(lk, [this] {
                    std::cout << "write woke up, test=" << (cb.size() < cb.capacity()) << std::endl; 
                    return cb.size() < cb.capacity();});
            cb.push_back(entry);
            std::cout << "Write notify_one" << std::endl;
        }
        cv.notify_one();
    }

    size_t get_number_entries() {
        std::unique_lock<std::mutex> lk(cv_mutex);
        return cb.size();
    }

  private:

    boost::circular_buffer<T> cb;
    std::condition_variable cv;
    std::mutex cv_mutex;
};

void write_loop(ring_buffer<int> *buffer) {

    for (int i = 0; i < 100000; ++i) {
        buffer->write(i);
    }
}

void read_loop(ring_buffer<int> *buffer) {

    for (int i = 0; i < 50000; ++i) {
        int val;
        buffer->read(val);
    }

}

int main() {

    ring_buffer<int> buffer(1000); 
    std::thread writer(write_loop, &buffer);
    std::thread reader(read_loop, &buffer);
    std::thread reader2(read_loop, &buffer);

    writer.join();
    reader.join();
    reader2.join();

    return 0;
}

我在输出中看到以下内容，其中唤醒了多个线程，因为谓词为false。

read woke up, test=0 
read woke up, test=0 
write woke up, test=1 

Answer 1

当您的每个读取线程检查是否应该等待，或者条件是否已经满足时，您将看到条件的初始测试。

从这里开始，wait（）的重载等价于

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

因此，仅当条件为true时才调用etc（），但必须首先检查条件。

read woke up, test=0  // tests condition on reader1 thread, false, wait is called
read woke up, test=0  // tests condition on reader2 thread, false, wait is called
write woke up, test=1 // tests condition on writer thread, true, wait is not called

如果写入了2个值，并且每个读卡器只读取一个值，这可能会很明显。