C++ 使用条件变量同步三个线程

我的应用程序中有三个线程，第一个线程需要等待来自另外两个线程的数据准备就绪。这两个线程同时准备数据。 为了做到这一点，我在C++中使用条件变量如下：

boost::mutex mut;       
boost::condition_variable cond;     

线程1:

    bool check_data_received()
    {
         return (data1_received && data2_received);
    }

    // Wait until socket data has arrived
    boost::unique_lock<boost::mutex> lock(mut);
    if (!cond.timed_wait(lock, boost::posix_time::milliseconds(200),
        boost::bind(&check_data_received)))
    {

    }

    {
        boost::lock_guard<boost::mutex> lock(mut);
        data1_received = true;
    }
    cond.notify_one();

    {
        boost::lock_guard<boost::mutex> lock(mut);
        data2_received = true;
    }
    cond.notify_one();

bool check\u data\u received（）
{
返回（接收到数据1和数据2）；
}
//等待套接字数据到达
boost：：唯一锁定（mut）；
如果（！cond.timed_wait（锁，boost:：posix_time:：毫秒（200），
boost:：bind（检查数据（接收到的数据）（&check）））
{
}

线程2:

    bool check_data_received()
    {
         return (data1_received && data2_received);
    }

    // Wait until socket data has arrived
    boost::unique_lock<boost::mutex> lock(mut);
    if (!cond.timed_wait(lock, boost::posix_time::milliseconds(200),
        boost::bind(&check_data_received)))
    {

    }

    {
        boost::lock_guard<boost::mutex> lock(mut);
        data1_received = true;
    }
    cond.notify_one();

    {
        boost::lock_guard<boost::mutex> lock(mut);
        data2_received = true;
    }
    cond.notify_one();

{
boost：：lock_guard lock（mut）；
接收到的数据1_=真；
}
第二，通知某人；

线程3:

    bool check_data_received()
    {
         return (data1_received && data2_received);
    }

    // Wait until socket data has arrived
    boost::unique_lock<boost::mutex> lock(mut);
    if (!cond.timed_wait(lock, boost::posix_time::milliseconds(200),
        boost::bind(&check_data_received)))
    {

    }

    {
        boost::lock_guard<boost::mutex> lock(mut);
        data1_received = true;
    }
    cond.notify_one();

    {
        boost::lock_guard<boost::mutex> lock(mut);
        data2_received = true;
    }
    cond.notify_one();

{
boost：：lock_guard lock（mut）；
接收到的数据2_=真；
}
第二，通知某人；

---

所以我的问题是这样做是正确的，还是有更有效的方法？我正在寻找最优化的等待方式。

看起来您需要一个信号量，所以您可以等待两个“资源”被“占用”

现在，用原子替换互斥。您仍然可以使用简历向服务员发出信号：

#include <boost/thread.hpp>

boost::mutex mut;       
boost::condition_variable cond;     

boost::atomic_bool data1_received(false);
boost::atomic_bool data2_received(false);

bool check_data_received()
{
    return (data1_received && data2_received);
}

void thread1()
{
    // Wait until socket data has arrived
    boost::unique_lock<boost::mutex> lock(mut);
    while (!cond.timed_wait(lock, boost::posix_time::milliseconds(200),
        boost::bind(&check_data_received)))
    {
        std::cout << "." << std::flush;
    }
}

void thread2()
{
    boost::this_thread::sleep_for(boost::chrono::milliseconds(rand() % 4000));
    data1_received = true;
    cond.notify_one();
}

void thread3()
{
    boost::this_thread::sleep_for(boost::chrono::milliseconds(rand() % 4000));
    data2_received = true;
    cond.notify_one();
}

int main()
{
    boost::thread_group g;
    g.create_thread(thread1);
    g.create_thread(thread2);
    g.create_thread(thread3);

    g.join_all();
}

#包括
mutexmut；
boost：：条件变量cond；
boost：：接收到原子布尔数据1（false）；
boost：：接收到原子布尔数据2（false）；
bool检查接收到的数据（）
{
返回（接收到数据1和数据2）；
}
void thread1（）
{
//等待套接字数据到达
boost：：唯一锁定（mut）；
而（！cond.timed_wait（锁，boost:：posix_time:：毫秒（200），
boost:：bind（检查数据（接收到的数据）（&check）））
{
std:：cout“等待”的“最佳方式”这是一个令人惊讶的强烈矛盾：）@sehe我知道等待并不好，会影响工作的并行性。这就是为什么我想知道，是否有其他方法可以实现我想要的：）谢谢你的回答，但与我的原始代码有什么不同。你仍然使用谓词等待，但对线程来说是这样的您用原子布尔替换了锁保护。这会带来什么性能改进？读取/写入共享状态（布尔）时不需要锁定。如果您希望连续加载，则“旋转”可能会有所帮助在这里没有互斥锁的条件下。然后你就实现了无锁同步。但是，无锁编程中没有阻塞等待，因此如果没有连续工作，这将在旋转时烧掉CPU。请参阅例如，如果你想，我可以稍后向你展示一个基于ad_屏障的解决方案。有时间就立即开始OK，我会很高兴看到thread_barrierOk。这是一个旋转版本（实际上，它在
thread1
中没有睡眠的情况下非常有用，因为如果您需要，锁定不会是一个问题（请参阅我的答案解决方案），否则它会100%锁定CPU）