如何正确使用condition_variable与timed_wait/timed_join？调试异常排查

问题描述 #

我在使用Boost线程库的条件变量时遇到异常行为：代码创建工作线程，通过condition_variable::timed_wait等待通知，若1秒未收到通知则打印"Hello"，收到通知则退出；主线程发送通知后调用timed_join等待线程退出。正常运行结果符合预期，但在Visual Studio中单步调试时，timed_join返回失败，且工作线程多次输出"Hello"。已知断点会影响时序，但此场景下不应出现失败，怀疑是否错误使用了条件变量与互斥锁。

注：断点后直接继续运行则正常；主线程加锁解锁互斥锁不影响单步调试结果。

代码示例：

#include <iostream>
#include <boost/thread.hpp>

#define SLEEP_DURATION 1000

static boost::thread m_powerThread;
static boost::condition_variable m_exitThreadCond;
static boost::mutex m_exitThreadMutex;

void ThreadFunc()
{
    boost::mutex::scoped_lock lock( m_exitThreadMutex );
    std::cout << "Thread starts waiting" << std::endl;
    while ( !m_exitThreadCond.timed_wait( lock, boost::posix_time::milliseconds( SLEEP_DURATION ) ) )
    {
        // timed-out: m_exitThreadCond was not notified
        std::cout << "Hello" << std::endl;
    }
    // m_exitThreadCond was notified, let's exit
    std::cout << "Exiting thread" << std::endl;
}

int main( int argc, char* argv[] )
{
    m_powerThread = boost::thread( boost::bind<void>(&ThreadFunc) );

    // make sure thread started for good
    boost::this_thread::sleep( boost::posix_time::milliseconds( 500 ) );

    m_exitThreadMutex.lock();
    m_exitThreadCond.notify_all();
    m_exitThreadMutex.unlock();

    /* Then wait for the thread to exit. */
    if ( m_powerThread.timed_join( boost::posix_time::milliseconds( 2*SLEEP_DURATION ) ) )
    {
        std::cout << "OK, joined thread" << std::endl;
    }
    else
    {
        std::cout << "KO, failed to joined thread" << std::endl;
    }

    return 0;
}

问题原因 #

你的代码核心问题是没有使用共享状态（谓词）配合条件变量，仅依赖timed_wait的返回值判断是否收到通知。条件变量的通知是一次性的——如果通知发送时，线程尚未进入timed_wait等待状态，这个通知就会丢失，线程永远无法感知到通知，只能不断进入超时循环。

在单步调试场景下，时序被断点彻底打乱：

1. 工作线程启动后，可能在打印"Thread starts waiting"后、进入timed_wait前被断点暂停；
2. 主线程继续执行，完成500ms休眠后发送通知，但此时工作线程并未在等待，通知直接丢失；
3. 工作线程恢复执行后进入timed_wait，因为没有收到有效通知，超时后打印"Hello"并再次进入循环；
4. 主线程调用timed_join等待2秒，而工作线程的timed_wait每次超时需要1秒，第一次超时打印后，第二次timed_wait尚未结束，timed_join就已超时，返回失败。

即使没有调试，这种写法也存在隐患：比如系统调度延迟导致工作线程未及时进入等待状态，主线程的通知同样会丢失，引发类似问题。

修正方案 #

添加一个共享的布尔变量作为退出标志，线程在timed_wait前后都检查这个标志，确保不会错过退出信号。修改后的代码如下：

#include <iostream>
#include <boost/thread.hpp>

#define SLEEP_DURATION 1000

static boost::thread m_powerThread;
static boost::condition_variable m_exitThreadCond;
static boost::mutex m_exitThreadMutex;
static bool m_shouldExit = false; // 添加共享退出标志

void ThreadFunc()
{
    boost::mutex::scoped_lock lock( m_exitThreadMutex );
    std::cout << "Thread starts waiting" << std::endl;
    // 循环条件改为检查退出标志，同时配合timed_wait
    while ( !m_shouldExit )
    {
        // timed_wait返回false表示超时，true表示被唤醒
        if ( m_exitThreadCond.timed_wait( lock, boost::posix_time::milliseconds( SLEEP_DURATION ) ) )
        {
            // 被唤醒后直接退出循环（因为m_shouldExit已被设置为true）
            break;
        }
        std::cout << "Hello" << std::endl;
    }
    std::cout << "Exiting thread" << std::endl;
}

int main( int argc, char* argv[] )
{
    m_powerThread = boost::thread( boost::bind<void>(&ThreadFunc) );

    boost::this_thread::sleep( boost::posix_time::milliseconds( 500 ) );

    boost::mutex::scoped_lock lock( m_exitThreadMutex );
    m_shouldExit = true; // 先设置退出标志
    m_exitThreadCond.notify_all(); // 再发送通知
    // 无需手动unlock，scoped_lock会自动释放

    if ( m_powerThread.timed_join( boost::posix_time::milliseconds( 2*SLEEP_DURATION ) ) )
    {
        std::cout << "OK, joined thread" << std::endl;
    }
    else
    {
        std::cout << "KO, failed to joined thread" << std::endl;
    }

    return 0;
}

关键修改点： #

1. 添加m_shouldExit共享布尔变量，作为线程退出的核心判断条件；
2. 工作线程的循环条件改为检查m_shouldExit，而非timed_wait的返回值；
3. 主线程发送通知前，先在锁保护下设置m_shouldExit = true，确保线程无论是否在等待，下次检查标志时都会退出；
4. 使用scoped_lock自动管理互斥锁，避免手动lock/unlock可能出现的错误。

这样修改后，即使调试时通知被丢失，工作线程在下次循环检查m_shouldExit时也会发现需要退出，不会一直陷入超时循环，timed_join也能正常等待线程退出。

内容的提问来源于stack exchange，提问作者jpo38