Question

我查了很多帖子，但无法确定答案是否与我想做的事情有关。我所能理解的只是使用线程。

我希望有一个Server对象不断检查Client对象中的布尔值，如果是真的，服务器应该执行某些操作并将标志设置为false。

我希望这个检查过程与我的主要平行完成。 btw服务器和客户端也必须做其他事情我不想放在与检查客户端标志的函数相同的线程

编辑：我需要有多个服务器和客户端对象

所以这就是我在C ++代码中的意思： 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;
}

所以非常感谢帮助。提前谢谢。

Answer 1

您可以使用将处理此检查的条件变量。

这个想法是你有一个标志设置为true / flase，具体取决于工作是否已完成（设置为false，并在工作方法完成时设置为true）。

等待方法意味着程序将等到某个条件被填满。您使用notify将此条件设置为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;
}

主程序是

#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;
}

希望有所帮助，问我是否有任何问题

不断检查c ++中的变量

1 个答案: