Question

没有std :: condition_variable的应用程序：

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

std::mutex mutex;
std::queue<int> queue;
int counter;

void loadData()
{
    while(true)
    {
        std::unique_lock<std::mutex> lock(mutex);
        queue.push(++counter);
        lock.unlock();
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

void writeData()
{
    while(true)
    {
        std::lock_guard<std::mutex> lock(mutex);
        while(queue.size() > 0)
        {
            std::cout << queue.front() << std::endl;
            queue.pop();
        }
    }
}

int main()
{
    std::thread thread1(loadData);
    std::thread thread2(writeData);
    thread1.join();
    thread2.join();
    return 0;
}

使用std :: condition_variable的应用程序：

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

std::mutex mutex;
std::queue<int> queue;
std::condition_variable condition_variable;
int counter;

void loadData()
{
    while(true)
    {
        std::unique_lock<std::mutex> lock(mutex);
        queue.push(++counter);
        lock.unlock();
        condition_variable.notify_one();
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

void writeData()
{
    while(true)
    {
        std::unique_lock<std::mutex> lock(mutex);
        condition_variable.wait(lock, [](){return !queue.empty();});
        std::cout << queue.front() << std::endl;
        queue.pop();
    }
}

int main()
{
    std::thread thread1(loadData);
    std::thread thread2(writeData);
    thread1.join();
    thread2.join();
    return 0;
}

如果我是对的，这意味着该应用程序的第二个版本是不安全的，因为queue.empty（）函数在没有任何同步的情况下使用，所以没有锁。还有我的问题是：我们是否应该使用condition_variables，如果它们引起之前提到过的问题？

Answer 1

你的第一个例子忙等待 - 锁上有一个线程，检查，然后释放锁。当没有任何处理时，这会增加互斥体的争用并浪费到整个CPU。

第二个例子让等待的线程大部分都在睡觉。只有在准备好数据时，或者当有一个＆＃34;虚假的唤醒时，它才会被唤醒。（有标准许可证）。

当它唤醒时，它会重新获取互斥锁并检查谓词。如果谓词失败，它会释放锁并再次等待条件变量。

这是安全的，因为谓词保证在你获得的互斥锁中运行并传递给wait函数。

Answer 2

第二个代码是安全的，因为对wait(lock, pred)的调用等同于（直接来自标准）：

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

致电wait(lock)释放（解锁）lock，并在通知时重新获取（锁定）。

在您的情况下，这相当于：

auto pred = [](){return !queue.empty();};
std::unique_lock<std::mutex> lock(mutex); // acquire
while (!pred) { // Ok, we are locked
    condition_variable.wait(lock); // release
    // if you get here, the lock as been re-acquired
}

因此pred的所有来电都是lock锁定/获得的 - 只要对queue的所有其他操作都受到保护，此处就没有问题。

condition_variable的目的

2 个答案: