boost条件变量(condition_variable…

本文讨论了在使用Boost库中的condition_variable时遇到的一个问题,即当使用recursive_mutex与condition_variable_any配合时,可能导致程序阻塞。作者分析了问题的原因,并提出了一个自定义的condition_variable_recursive_mutex类作为解决方案,该类能够处理递归锁的情况。同时,文章也提到了在Linux环境下由于pthread接口的限制,需要额外的方法来跟踪递归锁的次数。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

    好吧,本文也标题党了一回。因为在boost开发者眼里,这肯定不是bug,甚至算不上flaw,而是character,详见#2219 This works as designed 云云。如果搞懂原理后正确使用也一切OK,不过我觉得作为一个高质量的库,不应该对开发者提出这么高的要求,另外这个问题让我半夜调试鸡飞狗跳,难免带些情绪,所以姑且称其为bug吧。
    先说几句题外话:条件变量是并发开发的一大利器。君不见java提供的基本同步机制只有synchronize(相当于同线程可重入的临界区recursive mutex)和wait/notify(这就是条件变量了),虽然还有其他几个同步原语,但是都是deprecate的。使用条件变量开发并发应用的最大优势是更容易做对,也更容易阅读理解。并发应用是很难调试的,有的bug可以潜伏很久直到哪天把程序崩掉,所以这两点是很关键的。boost的thread库提供有recursive_mutex、condition_variable和condition_variable_any。condition_variable_any可以作用于任意的mutex,那是不是利用boost::recursive_mutex和boost::condition_variable_any,就可以programming c++ like java ? 在今天之前我是这么认为的,但事实证明没这么简单。
    先来看一个例子:
#include "xttime.h"
#include <iostream>
#include <boost/thread.hpp>

using namespace std;

class TestVC
{
public:

    TestVC()
    {
        running_flag = true;       
    }

    void stop()
    {
        running_flag = false;
        {
            boost::recursive_mutex::scoped_lock lock(mtx);
            cond.notify_all();
        }
    }

    void waitSignalThread()
    {
        boost::recursive_mutex::scoped_lock lock(mtx);   
        while(running_flag)
        {
            cout << "start wait signal" << endl;           
            cond.wait(mtx);
            cout << "finish wait signal" << endl;           
        }
    }

    void emitSignalThread()
    {
        while (running_flag)
        {
            {
                boost::recursive_mutex::scoped_lock lock(mtx);
                cout << "start emit singal" << endl;
                cond.notify_all();
                cout << "finish emit signal" << endl;
            }
            global::sleepms(10);
        }
    }

private:

    bool running_flag;
    boost::recursive_mutex mtx;
    boost::condition_variable_any cond;

};

int main()
{
    boost::thread_group grp;
    TestVC test;
   
    grp.create_thread(boost::bind(&TestVC::waitSignalThread, &test));
    grp.create_thread(boost::bind(&TestVC::emitSignalThread, &test));
       
    global::sleepms(100);
    test.stop();
    grp.join_all();

    return 0;
}

    例子很简单,运行后跟预期的一样,循环打印:start wait signal、start emit singal、finish emit signal、finish wait signal。接下来做一个小改动:将waitSignalThread分解成两个函数如下:
    void waitOneSignal()
    {
        boost::recursive_mutex::scoped_lock lock(mtx);   
        cout << "start wait signal" << endl;           
        cond.wait(mtx);
        cout << "finish wait signal" << endl;   
    }

    void waitSignalThread()
    {
        boost::recursive_mutex::scoped_lock lock(mtx);           
        while(running_flag)
        {
            waitOneSignal();                   
        }
    }

    结果呢?非常不幸跟预期的不同,打印start wait signal后程序堵住了。这是因为boost::condition_variable_any只知道它的参数是一个可以加解锁的对象,所以调用wait的时候只是进行了一次解锁操作,但是当waitOneSignal调用cond.wait(mtx)的时候,mtx被加锁了两次了,只解锁一次,emitSignal线程当然无法获取mtx的锁。
    解决方法关键在于条件变量要知道自己获得的lockable对象是recursive_mutex,在wait之前调用若干次unlock,wait后相应调用若干次lock(否则部分临界区将失去保护),代码如下(仅适用于win32平台,因为linux下的recursive_mutex是通过pthread的PTHREAD_MUTEX_RECURSIVE模式来实现的,没有保存当前加锁次数):
class condition_variable_recursive_mutex
{
public:

    condition_variable_recursive_mutex(){}
    ~condition_variable_recursive_mutex(){}

    void wait(boost::recursive_mutex& mtx)
    {
        int extra_lock = mtx.recursion_count - 1;
        for (int i = 0; i < extra_lock; i++)
        {
            mtx.unlock();
        }
        XASSERT(mtx.recursion_count == 1);       
        cond.wait(mtx);       
        for (int i = 0; i < extra_lock; i++)
        {
            mtx.lock();
        }
    }

    void notify_one()
    {
        cond.notify_one();
    }

    void notify_all()
    {
        cond.notify_all();
    }

private:

    boost::condition_variable_any cond;
};
    当使用recursive_mutex时使用上文condition_variable_recursive_mutex替代boost自带的条件变量就可以避免发生解锁不彻底的问题。如果要使用boost自带的条件变量也不是不行,只要确保wait的时候mutex只锁了一次即可——避免范围加锁的函数互相调用(如例子)和范围加锁的递归函数就可以基本满足这点了——这是挺麻烦的。
    最后一个问题:linux怎么办?事实上,我更关心Linux上能否正常运行。我感觉这是pthread接口设计的一个瑕疵:既然可以递归锁,为何没有方法获知总计锁了几次?为recursive_mutex加上计数即可最终解决该问题。

class xrecursive_mutex
{
public:
    xrecursive_mutex(): recursion_count(0){}
    ~xrecursive_mutex(){}

    //    serious warning: you must only call this func in the thread already hold permission of this mutex!
    int get_recursion_count()
             
        return recursion_count;
    }

    void lock()
    {
        mutex.lock();
        ++ recursion_count;
    }

    //    serious warning: you must only call this func in the thread already hold permission of this mutex!
    void unlock()
    {
        -- recursion_count;
        mutex.unlock();           
    }

    //    lock of RAII style
    class scoped_lock
    {
    public:
        scoped_lock(xrecursive_mutex& mtx_)
            : mtx(mtx_)
        {
            mtx.lock();
        }

        ~scoped_lock()
        {
            mtx.unlock();
        }

    private:       
        xrecursive_mutex& mtx;
    };

private:

    int recursion_count;
    boost::recursive_mutex mutex;
};

class condition_variable_recursive_mutex
{
public:
    condition_variable_recursive_mutex(){}
   
    ~condition_variable_recursive_mutex(){}

    void wait(xrecursive_mutex& mtx)
    {
        int extra_lock = mtx.get_recursion_count() - 1;
        for (int i = 0; i < extra_lock; i++)
        {
            mtx.unlock();
        }
        XASSERT(mtx.get_recursion_count() == 1);       
        cond.wait(mtx);       
        for (int i = 0; i < extra_lock; i++)
        {
            mtx.lock();
        }
    }

    void notify_one()
    {
        cond.notify_one();
    }

    void notify_all()
    {
        cond.notify_all();
    }

private:
    boost::condition_variable_any cond;
};




<think>我们正在讨论Boost 1.58中的condition_variable::wait_for方法。根据提供的引用,我们知道Boost提供了两种条件变量condition_variable(需要配合boost::mutex使用)和condition_variable_any(可配合更广泛的互斥量类型)。同时,C++11标准中的condition_variablewait方法有两种形式:无条件等待和带谓词条件的等待。类似地,wait_for也应该有类似的形式。 在Boost 1.58中,condition_variable::wait_for的用法应该与C++11标准类似,但需要注意Boost的版本可能有一些差异。根据Boost文档,wait_for方法通常有两种重载形式: 1. 无条件等待:指定一个相对时间长度,在条件变量上等待一段时间,如果超时则返回。 2. 带谓词条件的等待:在等待期间,除了检查超时,还会检查谓词条件是否满足,这样可以避免虚假唤醒。 由于我们使用的是Boost 1.58,我们可以参考Boost的官方文档。但是,这里我们根据已有的引用和C++11的类似用法来推断。 下面是一个使用boost::condition_variablewait_for方法的示例。我们将创建一个简单的生产者-消费者模型,其中消费者线程将等待一段时间,如果超过等待时间还没有数据,则执行超时处理。 步骤: 1. 包含必要的头文件。 2. 定义互斥量和条件变量。 3. 定义一个共享变量(例如队列)来传递数据。 4. 消费者线程使用wait_for等待,如果超时则处理超时,否则处理数据。 5. 生产者线程在产生数据后通知条件变量。 注意:由于我们使用的是boost::condition_variable,因此必须配合boost::mutex使用。 示例代码: ```cpp #include <boost/thread.hpp> #include <boost/chrono.hpp> #include <iostream> #include <queue> boost::mutex mut; boost::condition_variable cond; std::queue<int> data_queue; // 共享数据队列 void producer() { // 模拟生产数据 for (int i = 0; i < 5; ++i) { boost::this_thread::sleep_for(boost::chrono::seconds(1)); // 生产一个数据需要1秒 { boost::lock_guard<boost::mutex> lock(mut); data_queue.push(i); std::cout << "Produced: " << i << std::endl; } cond.notify_one(); // 通知一个等待的消费者 } } void consumer() { while (true) { boost::unique_lock<boost::mutex> lock(mut); // 使用wait_for等待2秒,如果超时则返回false // 这里使用带谓词的版本,避免虚假唤醒:当有数据时我们才继续 bool data_ready = cond.wait_for(lock, boost::chrono::seconds(2), []{ return !data_queue.empty(); }); if (data_ready) { // 有数据到来 int data = data_queue.front(); data_queue.pop(); lock.unlock(); // 提前解锁,减少锁的持有时间 std::cout << "Consumed: " << data << std::endl; } else { // 超时,没有数据 std::cout << "Timeout, no data." << std::endl; // 注意:这里我们只是简单退出,实际应用中可能根据情况处理 break; } } } int main() { boost::thread producer_thread(producer); boost::thread consumer_thread(consumer); producer_thread.join(); consumer_thread.join(); return 0; } ``` 在上面的示例中,消费者线程等待2秒。如果在这2秒内生产者通知并且队列不为空,则消费者线程会消费数据;如果超时(即2秒内没有数据),则打印超时信息并退出循环。 注意:wait_for的带谓词版本相当于: ```cpp while (!pred()) { if (wait_for(lock, timeout_duration) == boost::cv_status::timeout) { return pred(); } } return true; ``` 所以,它会在超时时返回谓词条件的当前状态(false),在条件满足时返回true。 另外,我们使用了boost::chrono::seconds来指定等待时间。 关于wait_for的返回值,在无条件等待版本中,它会返回一个枚举值(boost::cv_status::timeout或boost::cv_status::no_timeout)来表示是否超时。但在带谓词的版本中,它直接返回谓词条件的布尔值(如果条件满足则返回true,超时则返回false)。 因此,在示例中我们使用带谓词的版本,这样更简洁,并且能避免虚假唤醒。 希望这个示例能帮助你理解Boost 1.58中condition_variable::wait_for的用法。 §§相关问题§§ 1. 在Boost中,condition_variablecondition_variable_any有什么区别? 2. 如何避免条件变量的虚假唤醒? 3. 在生产者-消费者模型中,除了使用条件变量,还有哪些同步机制可以使用?</think>### Boost 1.58 中 condition_variable::wait_for 使用详解 在 Boost 1.58 中,`condition_variable::wait_for` 用于在指定时间范围内等待条件满足,若超时则自动唤醒线程。它有两种重载形式: 1. **基础等待**(返回等待结果状态) ```cpp template <class Rep, class Period> cv_status wait_for( unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time ); ``` 2. **谓词等待**(自动检查条件,避免虚假唤醒) ```cpp template <class Rep, class Period, class Predicate> bool wait_for( unique_lock<mutex>& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred ); ``` #### 完整示例代码 ```cpp #include <boost/thread.hpp> #include <boost/chrono.hpp> #include <iostream> boost::mutex mtx; boost::condition_variable cv; bool data_ready = false; // 消费者线程 void consumer() { boost::unique_lock<boost::mutex> lock(mtx); // 等待最多1秒(带谓词检查) if (cv.wait_for(lock, boost::chrono::seconds(1), []{ return data_ready; })) { std::cout << "✅ 数据已就绪" << std::endl; } else { std::cout << "⏱️ 等待超时" << std::endl; } } // 生产者线程 void producer() { boost::this_thread::sleep_for(boost::chrono::milliseconds(1500)); // 模拟延迟 { boost::lock_guard<boost::mutex> lock(mtx); data_ready = true; } cv.notify_one(); } int main() { boost::thread cons(consumer); boost::thread prod(producer); cons.join(); prod.join(); return 0; } ``` #### 关键点解析 1. **互斥量要求** 必须使用 `boost::unique_lock<boost::mutex>` 配合 `condition_variable`[^1] 2. **谓词优势** 带谓词的版本等价于: ```cpp while (!pred()) { if (wait_for(lock, rel_time) == cv_status::timeout) { return pred(); } } return true; ``` 可有效处理虚假唤醒[^3] 3. **返回值说明** - 基础版本返回 `cv_status::timeout` 或 `cv_status::no_timeout` - 谓词版本直接返回条件是否满足的布尔值 4. **时间单位** 使用 `boost::chrono` 时间类型: ```cpp cv.wait_for(lock, boost::chrono::milliseconds(500)); // 500毫秒 ``` #### 典型应用场景 1. 实时系统任务调度 2. 网络请求超时控制 3. 资源等待的优雅降级 4. 死锁检测机制 > ⚠️ **注意**:在 Boost 1.58 中,`condition_variable` 必须与 `boost::mutex` 配合使用,而 `condition_variable_any` 可适配更多互斥量类型[^1]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值