constantly checking a variable in c++ - c++

Question

I checked quite a few posts but could not be sure if answers were related to what I want to do. All I could understand was to use threads.
I want to have a Server object which constantly checks a boolean value in a Client object and in case it is true server should do something and turn the flag to false.
I want this checking process to be done parallel to my main. btw server and client have to do other things too which i dont want to put in the same thread as the function that checks the client's flag
EDIT: I need to have multiple objects of Server and Client
so here is what i mean in C++ code:
main.cpp
#include <iostream>
using namespace std;
class Client
{
public:
bool flag;
void setFlag(bool flagStat)
{
flag = flagStat;
}
bool getFlag()
{
return flag;
}
};
class Server
{
public:
void checkClientFlag(Client *client)
{
while (true)
{
if (client->getFlag())
{
alarmServer();
client->setFlag(false);
}
}
}
void alarmServer()
{
cout << "Client Flag UP!!!" << endl;
}
};
int main()
{
Server *newSrv = new Server;
Client *newCnt = new Client;
newSrv->checkClientFlag(newCnt);
return 0;
}
so help is appreciated.
Thank you in advance.

Answer 1

You can use condition variable that will deal with this checking for you.
The idea is that you have a flag that is set to true/flase depending on whether the work has been done (set up as false and will be set to true when the work method is done).
the wait method means that the program will wait until a certain condition is filled.
you use notify to set this condition to true
Server.h
#include <condition_variable>
#include <mutex>
class CServer
{
std::condition_variable & cv;
std::mutex & mut;
bool & flag;
public:
~CServer(void);
CServer::CServer(std::condition_variable & cv,
std::mutex & mut,
bool & flag);
CServer::CServer(CServer &);
int Notify();
int DisplayNotification();
std::condition_variable & getCondVar(){return cv;}
std::mutex & getMutex(){return mut;}
bool & getFlag(){return flag;}
};
Server.cpp
#include "Server.h"
#include <iostream>
using namespace std;
CServer::~CServer(void)
{
}
CServer::CServer(std::condition_variable & cv_,
std::mutex & mut_,
bool & flag_):
cv(cv_),
mut(mut_),
flag(flag_)
{
}
CServer::CServer(CServer &toCopy):
cv(toCopy.getCondVar()),
mut(toCopy.getMutex()),
flag(toCopy.getFlag())
{
flag=false;
cout<<"Copy constructor"<<std::endl;
}
int CServer::Notify()
{
{
std::lock_guard<std::mutex> lk(mut);
flag=true;
std::cout << "ready for notfication"<<endl;
}
cv.notify_one();
return 0;
}
int CServer::DisplayNotification()
{
// wait for the worker
{
std::unique_lock<std::mutex> lk(mut);
cv.wait(lk, [this]{return this->getFlag();});
}
cout<<"Notification displayed"<<endl;
return 0;
}
Client.h
#include <chrono>
#include "Server.h"
class CClient
{
CServer & serv;
std::chrono::seconds sleepTime;
bool finishedWork;
public:
CClient(CServer & serv,
std::chrono::seconds sleepTime);
~CClient(void);
int work();
};
Client.cpp
#include "Client.h"
#include <thread>
using namespace std;
CClient::CClient(CServer & serv_,
std::chrono::seconds sleepTime_):
serv(serv_),
sleepTime(sleepTime_),
finishedWork(false)
{
}
CClient::~CClient(void)
{
}
int CClient::work()
{
this_thread::sleep_for(sleepTime);
finishedWork=true;
serv.Notify();
return 0;
}
And the main program is
#include "Client.h"
#include <thread>
using namespace std;
int main()
{
std::chrono::seconds sleepTime=std::chrono::seconds(10);
//create client and server
condition_variable cv;
mutex mut;
bool flag=false;
CServer serv(cv,mut, flag);
CClient cli(serv,sleepTime);
//thread with the server
thread thServ(&CServer::DisplayNotification,serv);
////thread with the client
thread thCli (&CClient::work,cli);
////join threads
thServ.join();
thCli.join();
return 0;
}
Hope that helps, ask me if you have any questions