QT之QWaitCondition降低cpu占用率，从忙等待到高效同步

QWaitCondition降低cpu占用率，从忙等待到高效同步

闫有尽意无琼

878人浏览 · 2025-08-19 16:39:24

闫有尽意无琼 · 2025-08-19 16:39:24 发布

在多线程编程中，线程间的同步是一个核心问题。在处理线程等待时，经常会写出高CPU占用率的代码，其中最典型的就是使用忙等待（busy waiting）。本文将详细介绍如何使用Qt框

架中的QWaitCondition类来优雅地解决这一问题，有效降低CPU占用率。

一、占用率高分析

如上图，这种常见写法确实会导致 CPU 常驻一定百分比左右，原因是：

线程永远不会退出 while(true) 保持运行，即使没有任务也会醒来一次；
msleep(500) 只是让线程休眠 500ms 休眠期间 CPU 占用是 0，但醒来后要判断条件、调用函数 → 系统监视器会统计为少量 CPU 占用，就算循环里几乎什么都不做，CPU 也要处理线程切换；

总结，采用msleep其是一种实时性 和 CPU 占用 的权衡，msleep 越短线程被唤醒得越频繁，响应快，CPU 占用越高（比如 msleep(1) 就几乎是“忙等”，会吃掉比较多 CPU）。而 msleep 越长 CPU 占用低，但可能延迟处理任务（比如 500ms 意味着最坏情况延迟半秒）。这种写法的问题显而易见：

CPU持续进行无效的检查循环

即使使用msleep，仍然会产生不必要的上下文切换

响应延迟不可控

资源浪费不可避免

二、QWaitCondition：优雅的解决方案

QWaitCondition是Qt提供的条件变量实现，它允许线程在特定条件满足之前进入休眠状态，从而避免忙等待。

2.1、基本工作原理

QWaitCondition的核心机制：

wait() - 线程释放互斥锁并进入休眠状态
wakeOne()/wakeAll() - 唤醒一个或所有等待的线程
被唤醒的线程重新获取互斥锁并继续执行

2.2、wakeOne唤醒一个

下方演示一个最小可运行的 Qt C++ QWaitCondition 生产者–消费者 Demo。
这个程序有两个线程：

Producer：每隔一秒产生一个任务。
Consumer：只有收到任务才会被唤醒并处理，空闲时 CPU 完全是 0%

#include <QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
#include <QQueue>
#include <QDebug>

// 全局队列 & 条件变量
QMutex mutex;
QWaitCondition cond;
QQueue<int> queue;

// 消费者线程
class Consumer : public QThread {
protected:
    void run() override {
        while (true) {
            mutex.lock();
            // 如果队列为空，就等待
            while (queue.isEmpty()) {
                cond.wait(&mutex); // 会自动解锁并挂起，直到被唤醒
            }
            int task = queue.dequeue();
            mutex.unlock();

            qDebug() << "Consumer: processing task" << task;
            QThread::msleep(200); // 模拟耗时任务
        }
    }
};

// 生产者线程
class Producer : public QThread {
protected:
    void run() override {
        int counter = 0;
        while (true) {
            QThread::sleep(1); // 每秒生产一个任务
            mutex.lock();
            queue.enqueue(++counter);
            qDebug() << "Producer: produced task" << counter;
            cond.wakeOne(); // 唤醒一个等待的消费者
            mutex.unlock();
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Consumer consumer;
    Producer producer;
    consumer.start();
    producer.start();

    return a.exec();
}

Producer: produced task 1
Consumer: processing task 1
Producer: produced task 2
Consumer: processing task 2
...

此时观察任务管理器 / top，可以看到 CPU 占用在 没有任务时几乎 0%，有任务时才会短暂占用

2.3、wakeAll唤醒所有

下面创建 3 个消费者线程，同时等待任务队列里的数据，同时用 QMutexLocker 可以避免忘记 unlock() 导致死锁；

#include <QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QWaitCondition>
#include <QQueue>
#include <QDebug>

// 全局任务队列 & 条件变量
QMutex mutex;
QWaitCondition cond;
QQueue<int> queue;

// 消费者线程
class Consumer : public QThread {
public:
    Consumer(int id) : m_id(id) {}

protected:
    void run() override {
        while (true) {
            QMutexLocker locker(&mutex);

            // 如果队列为空，就等待
            while (queue.isEmpty()) {
                cond.wait(&mutex);  // 注意：这里必须传裸 QMutex 指针
            }

            int task = queue.dequeue();
            locker.unlock();  // 手动提前解锁，让其他线程能进入

            qDebug() << "Consumer" << m_id << "processing task" << task;
            QThread::msleep(300); // 模拟耗时任务
        }
    }

private:
    int m_id;
};

// 生产者线程
class Producer : public QThread {
protected:
    void run() override {
        int counter = 0;
        while (true) {
            QThread::sleep(1); // 每秒生产一个任务
            {
                QMutexLocker locker(&mutex);
                queue.enqueue(++counter);
                qDebug() << "Producer produced task" << counter;
                //cond.wakeOne(); // 唤醒一个等待的消费者
                cond.wakeAll();//所有消费者都被唤醒
            } // locker 作用域结束时自动解锁
        }
    }
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    // 启动 3 个消费者线程
    Consumer c1(1), c2(2), c3(3);
    Producer producer;
    c1.start();
    c2.start();
    c3.start();
    producer.start();

    return a.exec();
}

cond.wakeOne() → 每次只唤醒 一个等待的消费者（其他仍然挂起）。
cond.wakeAll() → 会唤醒 所有等待的消费者（此时谁先拿到锁，谁先消费）

QMutexLocker locker(&mutex); → 构造时自动加锁，析构时自动解锁。

cond.wait() 推荐传裸 QMutex*，不要传 QMutexLocker；

在消费者里 locker.unlock() 提前解锁，避免持锁期间去做耗时任务（否则会阻塞其他线程取任务）；

cond.wait(&mutex, 3000); // 也可以设置3秒超时防止死锁