Class variable has default value in each function call? - c++

Question

In MyClass there are two functions. FuncA sends a command to be executed while FuncB checks the progress in executing the command sent by FunA. As FuncB waits in a while loop until it makes sure the command was successfully executed, I call FuncB in a separate thread. The thread in which FunA is running should not wait in a while loop.
In main.cpp, there are two functions which run in two different threads. execute makes decisions and call FunA to send commands while check calls FuncB to check the made decisions has been executed.
As I don't want execute to send the same decision more than once, I first make sure that FuncA is not running and that FuncB has reset funcInUse to false.
myclass.h
class MyClass
{
public:
MyClass();
void FuncA(float x, floaty, floatz);
bool FuncB(void);
bool IsFuncInUse(void);
void QuitFuncA(void);
private:
bool funcInUse;
bool _x;
std::mutex mtx;
}
myclass.cpp
MyClass::MyClass()
{
funcInUse = false;
}
void MyClass::FuncA(float x, float y, float z)
{
if(funcInUse == true)
{
printf("FuncA already in use\n");
return;
}
// Gaining the lock, so that no two threads call the function at the same time
mtx.lock();
funcInUse = true;
mtx.unlock();
printf("INSIDE FuncA()::: %d\n", funcInUse?1:0);
printf("THIS FuncA() adr=%p \n", this);
// DO STUFF
}
bool MyClass::FuncB(void)
{
if(funcInUse == true)
{
printf("THIS ISPOSREACHED() adr=%p \n", this);
// DO STUFF
// Giving the lock back before returning
mtx.lock();
funcInUse = false;
mtx.unlock();
printf("Function is no more in use\n");
}
return true;
}
bool MyClass:IsFuncInUse(void)
{
return isFuncInUse;
}
void MyClass:QuitFuncA(void)
{
mtx.lock();
funcInUse = false;
mtx.unlock();
}
main.cpp
MyClass myClass;
void timerStart(std::function<void(void)> func, unsigned int interval)
{
std::thread([func, interval]()
{
while (true)
{
auto x = std::chrono::steady_clock::now() + std::chrono::milliseconds(interval);
func();
std::this_thread::sleep_until(x);
}
}).detach();
}
void execute(void)
{
if(/*some special condition*/)
{
myClass.QuitFuncA();
}
if(myClass.isFuncInUse() == false)
{
// USE THE FUNCTION
myClass.FuncA();
}
}
void check(void)
{
if(myClass.isFuncInUse())
{
status = myClass.FuncB();
printf("STATUS %d\n", status?true:false);
}
}
int main(void)
{
timerStart(execute, 500);
timerStart(check, 500);
}
The problem is: FuncA sets funcInUse to true in one iteration. In the next iteration, funcInUse is false again, although it was not been reset by FuncB. What may happen that resets funcInUse between the two iterations?
I tried printing this when calling the three functions in MyClass and all of them had the same address. I also tried to use bind with the class methods as I learned previously from here but it didn't work.
I tried to use mutex, semaphore and condition variables but I faced the problem that FuncA should gain the mutex while FuncB should release it after making sure the sent command has been executed (which is not allowed with mutex). And in one condition, a function in MyClass should reset isFuncInUse. Is there a better way to synchronize between the two methods than using funcInUse variable?
Thank you