与 recursive_mutex 一起使用时 condition_variable_any 的行为？

Question

当使用condition_variable_any 和recursive_mutex 时，recursive_mutex 是否可以在condition_variable_any::wait 等待时通常从其他线程获取？我对 Boost 和 C++11 的实现都感兴趣。

这是我主要关心的用例：

void bar();

boost::recursive_mutex mutex;
boost::condition_variable_any condvar;

void foo()
{
    boost::lock_guard<boost::recursive_mutex> lock(mutex);
    // Ownership level is now one

    bar();
}

void bar()
{
    boost::unique_lock<boost::recursive_mutex> lock(mutex);
    // Ownership level is now two

    condvar.wait(lock);
   // Does this fully release the recursive mutex,
   // so that other threads may acquire it while we're waiting?
   // Will the recursive_mutex ownership level
   // be restored to two after waiting?
}

Answer 1

通过对 Boost 文档的严格解释，我得出结论，condition_variable_any::wait一般不会导致 recursive_mutex 在等待通知时被其他线程获取。

班级condition_variable_any

template<typename lock_type> void wait(lock_type& lock)

效果：

以原子方式调用lock.unlock() 并阻塞当前线程。当调用this->notify_one() 或通知线程时，线程将解除阻塞 this->notify_all()，或者是虚假的。当线程被解除阻塞时（对于 不管什么原因），通过调用lock.lock()重新获取锁 在调用等待返回之前。锁也被重新获取 如果函数因异常退出，则调用 lock.lock()。

所以condvar.wait(lock) 将调用lock.unlock，而后者又调用mutex.unlock，这会将所有权级别降低一（不一定降至零）。

---

我已经编写了一个测试程序来证实我的上述结论（对于 Boost 和 C++11）：

#include <iostream>

#define USE_BOOST 1

#if USE_BOOST

#include <boost/chrono.hpp>
#include <boost/thread.hpp>
#include <boost/thread/condition_variable.hpp>
#include <boost/thread/locks.hpp>
#include <boost/thread/recursive_mutex.hpp>
namespace lib = boost;

#else

#include <chrono>
#include <thread>
#include <condition_variable>
#include <mutex>
namespace lib = std;

#endif

void bar();


lib::recursive_mutex mutex;
lib::condition_variable_any condvar;
int value = 0;

void foo()
{
    std::cout << "foo()\n";
    lib::lock_guard<lib::recursive_mutex> lock(mutex);
    // Ownership level is now one

    bar();
}

void bar()
{
    std::cout << "bar()\n";
    lib::unique_lock<lib::recursive_mutex> lock(mutex);
    // Ownership level is now two

    condvar.wait(lock); // Does this fully release the recursive mutex?

    std::cout << "value = " << value << "\n";
}

void notifier()
{
    std::cout << "notifier()\n";
    lib::this_thread::sleep_for(lib::chrono::seconds(3));
    std::cout << "after sleep\n";

    // --- Program deadlocks here ---
    lib::lock_guard<lib::recursive_mutex> lock(mutex);

    value = 42;
    std::cout << "before notify_one\n";
    condvar.notify_one();
}

int main()
{
    lib::thread t1(&foo); // This results in deadlock
    // lib::thread t1(&bar); // This doesn't result in deadlock
    lib::thread t2(&notifier);
    t1.join();
    t2.join();
}

---

我希望这可以帮助其他在混合condition_variable_any 和recursive_mutex 时面临同样困境的人。

Answer 2

您可以通过将参数allowed_unlock_count 添加到对mutex 对象进行操作的每个函数来修复此设计；关于allowed_unlock_count，有两种类型的保证：

(permit-unlock-depth) allowed_unlock_count代表mutex允许解锁的深度：调用者允许bar解锁互斥锁allowed_unlock_count次。解锁后，不保证mutex的状态。

(promise-unlock) allowed_unlock_count代表mutex的锁定深度：调用者保证解锁mutex正好allowed_unlock_count次将允许其他线程抢到@987654333 @对象。

这些保证是函数的前置条件和后置条件。

这里bar 依赖于（promise-unlock）：

// pre: mutex locking depth is allowed_unlock_count
void bar(int allowed_unlock_count)
{
    // mutex locking depth is allowed_unlock_count
    boost::unique_lock<boost::recursive_mutex> lock(mutex);
    // mutex locking depth is allowed_unlock_count+1

    // you might want to turn theses loops
    // into an a special lock object!
    for (int i=0; i<allowed_unlock_count; ++i)
        mutex.unlock();
    // mutex locking depth is 1

    condvar.wait(lock); // other threads can grab mutex

    // mutex locking depth is 1
    for (int i=0; i<allowed_unlock_count; ++i)
        mutex.lock();
    // mutex locking depth is allowed_unlock_count+1
}
// post: mutex locking depth is allowed_unlock_count

被调用函数必须明确允许调用者减少锁定深度。