C++ 一段时间后CPU使用率高

我有以下代码，在基于linux的设备中作为服务运行

它有一个mqtt回调，它在任何时候 一个是在订阅的主题上发布它

一个线程是处理队列上的传入消息。处理后，结果消息将被推送到out_消息队列

还有一个线程用于处理传出消息队列

我使用了condition_变量来定义线程之间的资源共享 问题是，经过一段时间（随机时间），该应用程序的cpu利用率达到100%。给定代码中的任何问题都可以更正我的流程。请帮帮我！！事先非常感谢

void pushMessage(std::string rData) {
    in_mutex.lock();
    in_queue.push(rData);
    in_mutex.unlock();
    in_cv.notify_all();
}

void pushOutGoingMessage(Json::Value data) {
    out_mutex.lock();
    out_queue.push(data);
    out_mutex.unlock();
    out_cv.notify_all();
}
void processOutGoingMessages() {
    while (true) {
        Json::Value data;
        {
            std::unique_lock<std::mutex> lock(out_mutex);
            while (out_queue.empty()) {
                out_cv.wait(lock);
            }
            data = out_queue.front();
            out_queue.pop();
            lock.unlock();
        }
        if (!data.isNull()) {
            parseOutGoingMessages(data);
        }
    }
}

void processMessage() {
    while (true) {
        std::string data = "NO_DATA";
        {
            std::unique_lock<std::mutex> lock(in_mutex, std::try_to_lock);
            if (!lock.owns_lock()) {

            } else {
                while (in_queue.empty()) {
                    in_cv.wait(lock);
                }
                data = in_queue.front();
                in_queue.pop();
                lock.unlock();
            }
        }
        if (data.compare("NO_DATA") != 0) {
            parseMessage(data);
        }
    }
}

void parseOutGoingMessages(Json::Value rJsonMessage) {
    // mqtt client send method
    mqtt_client.push_message(rJsonMessage.toStyledString(),
            rJsonMessage["destination"].asString());
}

void parseMessage(std::string rMessage) {
    try {
        debug(rMessage);
        // application logic
    } catch (std::exception &e) {
        debug("ERRO HANDLED IN PARSING ::" + std::string(e.what()));
    }
}

void connectMQTT() {
    // connection params
}

void OnConnectionLost(void *context, char *cause) {
    // retry logic
    connectMQTT();
}

void delivered(void *context, MQTTClient_deliveryToken dt) {

}
int OnMessageArrived(void *context, char *topicName, int topicLen,
        MQTTClient_message *message) {
    if (!message->retained) {
        std::string msg((char *) message->payload, message->payloadlen);
        pushMessage(msg);
    }
    MQTTClient_freeMessage(&message);
    MQTTClient_free(topicName);
    return 1;
}
void send(Json::Value rData,std::string rDestination) {
    Json::Value jsonNotification;
    jsonNotification["destination"] = rDestination;
    jsonNotification["data"] = rData;
    pushOutGoingMessage(jsonNotification);
}
int main(int argc, char **argv) {
    connectMQTT();
    std::thread procInMessage(processMessage);
    std::thread procOutMessage(processOutGoingMessages);
    procInMessage.join();
    procOutMessage.join();
}

void推送消息（std:：string rData）{
in_mutex.lock（）；
in_queue.push（rData）；
in_mutex.unlock（）；
在简历中通知所有人（）；
}
void pushOutGoingMessage（Json:：值数据）{
out_mutex.lock（）；
输出队列推送（数据）；
out_mutex.unlock（）；
out_cv.notify_all（）；
}
void processOutGoingMessages（）{
while（true）{
Json：：值数据；
{
std：：唯一锁（out\u互斥）；
while（out_queue.empty（））{
出舱等待（锁定）；
}
data=out_queue.front（）；
out_queue.pop（）；
lock.unlock（）；
}
如果（！data.isNull（））{
解析输出消息（数据）；
}
}
}
void processMessage（）{
while（true）{
std:：string data=“无数据”；
{
std:：unique_lock锁（在互斥锁中，std:：try_to_lock）；
如果（！lock.own_lock（））{
}否则{
while（在_queue.empty（）中）{
在循环中等待（锁定）；
}
data=in_queue.front（）；
in_queue.pop（）；
lock.unlock（）；
}
}
如果（数据比较（“无数据”）！=0）{
解析消息（数据）；
}
}
}
void parseOutGoingMessages（Json:：Value rJsonMessage）{
//mqtt客户端发送方法
mqtt_client.push_消息（rJsonMessage.toStyledString（），
rJsonMessage[“destination”].asString（））；
}
void parseMessage（std:：string rMessage）{
试一试{
调试（rMessage）；
//应用逻辑
}捕获（标准：：异常&e）{
调试（“解析中处理的错误：：”+std:：string（例如what（））；
}
}
void connectMQTT（）{
//连接参数
}
void onconnectionloss（void*上下文，char*原因）{
//重试逻辑
connectMQTT（）；
}
已交付void（void*上下文，MQTTClient_deliveryToken dt）{
}
int-OnMessageArrived（void*context，char*topicName，int-topicLen，
MQTTClient_消息*消息）{
如果（！消息->保留）{
std:：string msg（（char*）message->payload，message->payloadlen）；
推送信息（msg）；
}
MQTTClient_freeMessage（&message）；
MQTTClient_free（topicName）；
返回1；
}
void send（Json:：Value rData，std:：string rdestation）{
Json:：Value-jsonNotification；
jsonNotification[“目的地”]=rDestination；
jsonNotification[“数据”]=rData；
推出消息（jsonNotification）；
}
int main（int argc，字符**argv）{
connectMQTT（）；
std：：线程进程消息（processMessage）；
std:：thread procOutMessage（processoutingmessages）；
procInMessage.join（）；
procOutMessage.join（）；
}

谢谢@MatthewFisher和@Mike Vine。我只是修改了两个队列的推送方法

void pushMessage(std::string rData) {
//  in_mutex.lock();
//  in_queue.push(rData);
//  in_mutex.unlock();
//  in_cv.notify_all();
    std::unique_lock<std::mutex> lock(in_mutex);
    in_queue.push(rData);
    lock.unlock();
    in_cv.notify_all();
}

void pushOutGoingMessage(Json::Value data) {
//  out_mutex.lock();
//  out_queue.push(data);
//  out_mutex.unlock();
//  out_cv.notify_all();
    std::unique_lock<std::mutex> lock(out_mutex);
    out_queue.push(data);
    lock.unlock();
    out_cv.notify_all();
}

void推送消息（std:：string rData）{
//in_mutex.lock（）；
//in_queue.push（rData）；
//in_mutex.unlock（）；
//在简历中通知所有人（）；
std：：唯一锁（在互斥锁中）；
in_queue.push（rData）；
lock.unlock（）；
在简历中通知所有人（）；
}
void pushOutGoingMessage（Json:：值数据）{
//out_mutex.lock（）；
//输出队列推送（数据）；
//out_mutex.unlock（）；
//out_cv.notify_all（）；
std：：唯一锁（out\u互斥）；
输出队列推送（数据）；
lock.unlock（）；
out_cv.notify_all（）；
}

---

我想问题已经解决了。这是由于两个队列的push方法中的（！lock.owns_lock（））{}引起的

您是否使用了调试器来查看在此期间执行的代码？当我以调试模式启动应用程序时，我没有发现任何高cpu使用率。但是，当我在系统中作为守护进程服务运行此服务时，我发现cpu使用率很高。所有循环都没有任何类型的睡眠。添加一些调试cout或等到出现这种情况，然后附加调试器以查看堆栈。如果（！lock.owns_lock（））{}无法获取锁，则该行可能会运行。可能pushMessage中的异常导致锁被卡住？这里有一些不确定的代码，其中任何一个都可能导致这种情况。首先，当您尝试

try\u to\u lock

时，会出现一个热循环。这将消耗大量CPU，可能导致其他部件处理不足。只需删除该参数。其次，您在许多地方使用手动锁定/解锁-这意味着如果出于任何原因引发异常，您将永久锁定该异常。始终使用

堆栈保护

或

唯一锁定

。最后，您应该使用

条件变量：：wait

的谓词版本，这意味着您不需要那些“whilenotempty”循环。