C++ 如何实现阻塞处理循环？

我想在一个工作线程中实现一个处理循环，以便它在出现问题和阻塞（线程休眠）时处理队列中的数据。否则，这可能吗？也应在没有任何明显延迟的情况下工作

简单地说：

std::deque<Foo> queue;

void worker() 
{
    while (active) {
        blockAndWaitForData();

        while (!queue.empty()) {
            doSomething(queue.front());
            queue.pop_front();
        }
    }
}

std:：deque队列；
void worker（）
{
while（活动）{
blockAndWaitForData（）；
而（！queue.empty（））{
doSomething（queue.front（））；
queue.pop_front（）；
}
}
}

当然，队列需要加上一些其他细节被锁定

---

如果需要，Linux API也可以直接使用。

在C++11标准中，有一些东西可以满足您的需要。它是条件变量。它允许您等待其他线程通知它。所以你们的工人可以等到生产商这样通知你们。请注意，这是一个非常简单的示例，在大多数情况下都不完善，但给出了如何实现的要点

std::deque<int> q;
std::mutex m;
std::condition_variable cv;

void worker() {
    while (active) {
        std::deque<int> vals;
        {
            std::unique_lock<std::mutex> l(m);
            cv.wait(l, []{return q.empty();});
            vals = std::move(q);
            q.clear();
        }
        for (const auto& val : vals)
            doSomething(val);
    }
}

void producer() {
    while (active) {
        {
            std::unique_lock<std::mutex> l(m);
            q.push_back(produce());
        }  
        cv.notify_one();
   }
}

std:：deque q；
std：：互斥m；
std：：条件变量cv；
void worker（）{
while（活动）{
标准：德克瓦尔斯；
{
std：：唯一锁l（m）；
cv.wait（l，[{返回q.empty（）；}）；
VAL=标准：：移动（q）；
q、 清除（）；
}
用于（常数自动和val:val）
剂量测定法（val）；
}
}
无效生产者（）{
while（活动）{
{
std：：唯一锁l（m）；
q、 向后推（生产（））；
}  
cv.通知_one（）；
}
}

看看，另外，最好使用某种形式的无锁队列（例如

boost:：lockfree:：queue

）。使用a来表示数据的可用性。更好的是，使用一个。你所要求的有一个名称：你要求的是一个阻塞队列。也就是说，一个队列，其方法会自动阻止试图访问

前端

对象的调用方，直到有对象可访问为止。请注意，使用此代码，

m

在执行

doSomething

期间被锁定，这在实践中可能非常低效。我不确定OP是否看到了这一点，他们是否不熟悉条件变量。