Question

修改以更好地解释问题：

我希望将一个回调函数从一个类传递到另一个类，从class1到class2。我不希望class2知道关于class1的任何信息。

我的下面的代码工作正常，但我想在这里使用不同的线程。通过排除类等的单独cpp文件，代码已经非常简化，但希望我能够理解我的想法。

我希望class1运行一些线程调用class1的不同成员函数，然后让class2调用它的成员函数，因此处理来自class1的回调的函数。

我不确定如何实现这一点。如果在class2中已经运行了一个调用“FuncToExecuteCallback”的线程。如何从class1中运行的不同线程注册回调。或者我应该在调用它时启动在“FuncToExecuteCallback”内部运行的线程。任何帮助深表感谢。感谢

// class which contains callback to be sent to another class
class class1
{
public:
    class1(class2& d);
    // call back function to be passed elsewhere
    void MyCallBack()
    {
        cout<<"Inside CallBack Function!!"<<endl;   
    }
    void RegisterCallback()
    {
       d.FuncToExecuteCallback(std::bind(&class1::MyCallBack, this)); 
    }
    void CheckValues()
    {
         //some code
    }
private:
    class2& d;

};

// class which handles the callback
class class2
{
    public:
        bool mySignal = false;
        typedef std::function<void(void)> funcType;
        void FuncToExecuteCallback( funcType f)
        {
         //This function should be running in a separate thread

              for (;;)
              {
                  if (mySignal == true)
                      f();
              }
};

// main function
int main(int argc, char *argv[])
{
    class2 c2;

    std::thread th1
    {
        [&]{
            class1 c1{c2};
            c1.RegisterCallback();   // I'd like a separate thread to be spawn here that would call FuncToExecuteCallback from class2 
            for (;;)
            {
                c1.CheckValues();
                // execute more functions from class1 ....
                // ...
            }
    };
}

Answer 1

只需在代码中添加互斥锁：

#include <mutex>

class class2;

class class1{
    public:
        class1(class2 &c2): m_c2{c2}{}

        void func(){}

        void RegisterCallback();

    private:
        class2 &m_c2;
};

class class2{
    public:
        template<typename Func>
        void ExecuteFunc(Func &&f){
            std::unique_lock<std::mutex> lock{m_mut};
            f();
        }

    private:
        std::mutex m_mut;
};

void class1::RegisterCallback(){
    m_c2.ExecuteFunc([this]{ this->func(); });
}

然后，无论同一class1中有多少ExecuteFunc个来电class2，class2内的任何数据都不会有竞争。但是，这并不能保证锁定的顺序。

e.g。在ExecuteFunc的多个主题中运行main：

#include <thread>
#include "myclasses.hpp"

int main(int argc, char *argv[]){
    myclass2 c2;

    std::thread th0{
        [&]{
            class1 c1{c2};
            c1.RegisterCallback();
        }
    };
    std::thread th1{
        [&]{
            class1 c1{c2};
            c1.RegisterCallback();
        }
    };

    th0.join();
    th1.join();
}

使用带线程的回调

1 个答案: