C++ 如何将blocking waitUntil（）方法写入使用std:：atomics的池

我有一个验证类，它使用ah threadpool来处理它的所有作业

现在，当用户请求时，我启动一个线程，通过从磁盘读取来为验证类提供作业。我确信在某一点上，阅读会比处理快。所以我想写一个方法，如果处理的作业超过1000个，那么这个线程可以等待

我已经介绍了一个原子，它在添加作业时增加，在完成作业时减少

我试图添加一个方法，但效果不太好。我知道一定有可能使用更好的东西

void Validator::waitUntilAvailable() {
    while (m_blocksInFlight > 1000) { // thats my atomic
        usleep(50000); // seems to be unavailable on Windows.
    }
}

这里有没有人能帮助我用一种非投票的方法来解决我的问题

---

谢谢。

您需要等待一个条件，但没有等待机制

该机制是std:：condition\u变量和std:：mutex。例如：

class Validator
{
    std::mutex m_mutex;
    std::condition_variable m_condition;
    std::atomic<int> m_blocksInFlight{0};

    bool test() const {
        return m_blocksInFlight.load(std::memory_order_relaxed) > 1000;
    }

    void addJob() {
        ++m_blocksInFlight;

        // Only lock the mutex when the test succeeds.
        if(this->test()) {
            std::unique_lock<decltype(m_mutex)> lock(m_mutex);
            m_condition.notify_one();
        }
    }

    void waitUntilAvailable() {
        std::unique_lock<decltype(m_mutex)> lock(m_mutex);
        while(!this->test())
            m_condition.wait(lock);
    }
};

类验证程序
{
std:：mutex m_mutex；
std：：条件变量m_条件；
std：：原子m_块{0}；
布尔测试（）常数{
返回m_blocksInFlight.load（标准：：内存\u顺序\u松弛）>1000；
}
void addJob（）{
++m_blocksInFlight；
//仅在测试成功时锁定互斥锁。
如果（此->测试（））{
std:：唯一的锁锁（m U mutex）；
m_条件。通知_one（）；
}
}
void waituntilavable（）{
std：：唯一的_锁（m_互斥）；
而（！this->test（））
m_状态。等待（锁定）；
}
};

听起来像是信号灯的完美用法。。。这里有一个简单的实现：@richardhoges看起来像是（…）的std：：this_thread：：sleep_的副本。我已经读过关于这个条件的内容，但还没有完全理解它将如何应用。减少m_阻塞的代码看起来如何？我想它也需要对互斥体做些什么？