在不同的函数中锁定/解锁 std::unique_lock

Question

我正在编写一个使用条件变量的程序：

bool flag;
std::mutex mtx;
std::condition_variable cond;

{
  std::unique_lock<std::mutex> lock(mtx);
  cond.wait(lock, [&]{ return flag; });

  // ... do some stuff
  // ... do some more stuff

  flag = false;

} // lock unlocked here

现在我面临的问题是“做一些事情”和“做更多事情”实际上是在两个单独的回调函数中实现的，这些函数从其他地方一个接一个地调用，即：

void callback1() {
   std::unique_lock<std::mutex> lock(mtx);
   cond.wait(lock, [&]{ return flag; });

   // ... do some stuff
} // ERROR! lock unlocked too early

void callback2() {
   // ... do some more stuff
  flag = false;
} // lock should be unlocked here

我该如何解决这个问题？我可以将这两个回调封装在某个将锁作为成员变量保存的对象中，但在我看来，这违反了std::unique_lock 的预期语义。

编辑：更多上下文：

其他人编写了一个类Foo，如下所示：

class Foo
{
public:
  void bar() {
    before_bar_callback();

    // ...
    
    after_bar_callback();
  }

private:
  virtual void before_bar_callback() {}
  virtual void after_bar_callback() {}
};

我无法修改Foo::bar，它在单独的线程中运行。我想等待before_bar_callback 中的条件变量，然后设置flag = false 并解锁after_bar_callback 中的关联锁。

Answer 1

根据您的信息，这是我最接近一种 RAII 方法的方法。 当一个类没有做你想做的事时，有时包装它会有所帮助。 这就是我能想到的。理想情况下，您仍然应该检查 Foo 是否仍不能被“所有者”修改。

想法：在 Foo 有机会完成它的工作并调用你的回调之前获取一个锁。这样你就知道锁在你的回调中是活跃的。

#include <functional>
#include <mutex>
#include <iostream>
#include <condition_variable>

//-------------------------------------------------------------------------
// your stand in for Foo,
// the class you cannot change

class  Foo 
{
public:
    Foo() = default;
    virtual ~Foo() = default;

    void bar()
    {
        // todo construct a context here
        before_callback();
        // work here
        after_callback();
        // and destroy it here.
    }

private:
    virtual void before_callback() {};
    virtual void after_callback() {};

};

//-------------------------------------------------------------------------
// A class that should look like Foo but wraps it
// Foo is a member and FooWrapper can intercept calls
// to Foo and do extra things.

class MyFoo :
    protected Foo
{
public:
    MyFoo() = default;
    virtual ~MyFoo() = default;

    // shadows base classes bar intentionally
    void bar() 
    {
        std::unique_lock<std::mutex> lock{ m_mtx };
        m_lock = &lock;
        Foo::bar();
    };

    void before_callback() override
    {
        //lock is active
        m_cv.wait(*m_lock, [this] {return m_flag; });
        std::cout << "before_callback" << std::endl;
    }

    void after_callback() override
    {
        //lock is active
        std::cout << "after_callback" << std::endl;
    }

private:
    bool m_flag{ true };
    std::condition_variable m_cv;
    std::unique_lock<std::mutex>* m_lock{ nullptr };
    std::mutex m_mtx;
};

int main()
{
    MyFoo foo;
    foo.bar();

    return 0;
}