using callbacks with threads - c++

Question

Modified to explain better the problem:
I wish to pass a callback function from one class to another , from class1 to class2. I don't want class2 to know anything about class1.
My below code works fine, but I would like to involve using different threads here. The code has been simplified very much by excluding the separate cpp files for the classes etc. but hopefully I get my idea across.
I would like class1 to be running some thread calling different member functions of class1 and then have class2 calling its member functions, hence the function that handles the callback from class1.
I'm not sure how to implement this. If there is a thread already running in class2 that is calling "FuncToExecuteCallback". How can I register the callback from the different thread running in class1. Or should I just start a thread running inside "FuncToExecuteCallback" when it is called.
Any help is much appreciated . Thanks
// 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

Just add a mutex to your code:
#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(); });
}
Then no matter how many class1's call ExecuteFunc on the same class2 there will be no race on any data within the class2. This gives no guarantee about order of locking, though.
e.g. to run ExecuteFunc in multiple threads from 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();
}