QT定时器

1.定时器QTimer类基础

1.1基础使用方式

创建一个QTimer对象，将信号timeout()与相应的槽函数相连，然后调用start()函数。接下来，每隔一段时间，定时器便会发出一次timeout()信号。

// 创建定时器对象
QTimer *timer = new QTimer(this);

// 连接超时信号到槽函数
connect(timer, &QTimer::timeout, this, &MyClass::handleTimeout);

// 启动定时器 - 方式1：直接在start中设置间隔
timer->start(1000); // 每1000毫秒触发一次

// 启动定时器 - 方式2：先设置间隔再启动
timer->setInterval(1000);  // 设置间隔时间
timer->start();

// 停止定时器
timer->stop();

// 检查定时器状态
if(timer->isActive()) {
    qDebug() << "定时器正在运行";
}

// 获取剩余时间
int remaining = timer->remainingTime();

// 删除定时器
delete timer;

1.2 单次定时器

Qt提供了便捷的单次定时器功能，无需创建定时器对象：

// 单次定时器 - 在指定时间后执行一次
QTimer::singleShot(500, this, &MyClass::handleSingleShot);

// 带参数的单次定时器
QTimer::singleShot(1000, [=](){
    // 使用lambda表达式处理超时
    doSomething();
});

1.3 定时器精度控制

Qt允许设置不同的定时器精度，平衡精度和资源消耗：

// 设置定时器类型
timer->setTimerType(Qt::PreciseTimer);   // 高精度但更高功耗
// timer->setTimerType(Qt::CoarseTimer); // 默认，平衡精度和功耗
// timer->setTimerType(Qt::VeryCoarseTimer); // 低精度，低功耗

1.4 定时器超时处理

定时器超时处理有两种方式：

• 直接在槽函数中处理
• 在超时信号中处理

1.4.1 直接在槽函数中处理

直接在槽函数中处理超时信号，可以方便地处理定时器超时事件。

void MyClass::handleTimeout()
{
    // 处理超时事件
}

1.4.2 在超时信号中处理

在超时信号中处理超时事件，可以方便地获取定时器的剩余时间。

void MyClass::handleTimeout()
{
    int remaining = timer->remainingTime();
    // 处理超时事件
}

2.多线程中的定时器使用

2.1在多线程中使用QTimer

当需要在QThread子类中使用定时器时，需要注意线程亲和性问题：

// 正确的方式：在线程构造函数中创建定时器，但不设置父对象
TestThread::TestThread(QObject *parent) 
    : QThread(parent), m_pTimer(nullptr)
{
    m_pTimer = new QTimer(); // 不设置父对象
    m_pTimer->setInterval(1000);
    m_pTimer->moveToThread(this); // 确保定时器属于这个线程
}

void TestThread::run()
{
    // 确保定时器已经移动到当前线程
    if(m_pTimer->thread() != this) {
        m_pTimer->moveToThread(this);
    }
    
    connect(m_pTimer, &QTimer::timeout, this, &TestThread::timeoutSlot);
    m_pTimer->start();
    
    // 启动事件循环
    exec();
    
    // 清理资源
    if(m_pTimer) {
        m_pTimer->stop();
        m_pTimer->deleteLater(); // 使用deleteLater安全删除
        m_pTimer = nullptr;
    }
}

2.2 使用moveToThread改变定时器线程

无需子类化线程，通过moveToThread方法管理定时器线程：

TestClass::TestClass(QWidget *parent)
    : QWidget(parent)
{
    m_pThread = new QThread(this);
    m_pTimer = new QTimer(); // 不设置父对象
    m_pTimer->moveToThread(m_pThread);
    m_pTimer->setInterval(1000);
    
    // 连接线程启动信号到定时器启动槽
    connect(m_pThread, &QThread::started, m_pTimer, &QTimer::start);
    
    // 连接定时器超时信号，注意选择合适的连接类型
    connect(m_pTimer, &QTimer::timeout, 
            this, &TestClass::timeOutSlot, 
            Qt::DirectConnection); // 根据需求选择连接类型
    
    // 启动线程
    m_pThread->start();
}

2.3 信号槽连接类型选择

在多线程环境中，正确选择连接类型至关重要：

// Qt::DirectConnection - 槽函数在信号发出的线程中立即执行
// 适用于发送者和接收者在同一线程的情况

// Qt::QueuedConnection - 槽函数在接收者所在线程的事件循环中执行
// 适用于跨线程通信，线程安全

// Qt::BlockingQueuedConnection - 类似QueuedConnection，但会阻塞发送线程
// 适用于需要同步执行的跨线程调用

// Qt::AutoConnection - 默认值，自动选择最合适的连接方式
// 如果发送者和接收者在同一线程，使用DirectConnection，否则使用QueuedConnection

// 示例：跨线程连接，使用QueuedConnection确保线程安全
connect(m_pTimer, &QTimer::timeout, 
        this, &MyClass::onTimeout, 
        Qt::QueuedConnection);

3.多定时器管理

3.1 使用QObject内置定时器功能

对于需要管理多个定时器的场景，可以使用QObject的内置定时器功能，需要重写timerEvent()函数处理定时器事件。

class MultiTimerObject : public QObject {
    Q_OBJECT
    
public:
    MultiTimerObject(QObject *parent = nullptr) 
        : QObject(parent), m_timer1(-1), m_timer2(-1) {}
    
    void startTimers() {
        m_timer1 = startTimer(1000); // 1秒间隔，返回定时器ID
        m_timer2 = startTimer(500);  // 0.5秒间隔
    }
    
    void stopTimer(int id) {
        killTimer(id); // 停止指定ID的定时器
    }
    
protected:
    void timerEvent(QTimerEvent *event) override {
        if(event->timerId() == m_timer1) {
            // 处理定时器1超时
            handleTimer1Timeout();
        } else if(event->timerId() == m_timer2) {
            // 处理定时器2超时
            handleTimer2Timeout();
        }
    }
    
private:
    int m_timer1;
    int m_timer2;
    
    void handleTimer1Timeout() {
        // 处理定时器1超时
    }
    
    void handleTimer2Timeout() {
        // 处理定时器2超时
    }
};

4.注意事项和最佳实践

4.1 定时器精度和性能

• 定时器不保证绝对精确，实际间隔受系统负载影响

• 最小有效间隔通常为10-20毫秒，取决于操作系统

• 高精度定时器（PreciseTimer）会消耗更多系统资源

• 对于不需要高精度的场景，使用CoarseTimer或VeryCoarseTimer

4.2 资源清理最佳实践

// 使用deleteLater而不是直接delete，确保在正确线程中删除
void cleanupTimer() {
    if(m_pTimer) {
        m_pTimer->stop();
        m_pTimer->deleteLater(); // 安全删除
        m_pTimer = nullptr;
    }
}

// 在类析构函数中停止定时器
MyClass::~MyClass() {
    if(m_pTimer && m_pTimer->isActive()) {
        m_pTimer->stop();
    }
}

4.3 跨线程使用注意事项

• 确保定时器对象在正确的线程中创建和使用
• 使用moveToThread改变对象线程亲和性
• 选择合适的信号槽连接类型确保线程安全
• 避免在定时器槽函数中执行耗时操作，以免阻塞事件循环

4.4 替代方案

对于需要更高精度或更复杂调度需求的场景，可以考虑：

// 使用QElapsedTimer测量时间间隔
QElapsedTimer timer;
timer.start();

// 在需要检查时间的地方
if(timer.hasExpired(1000)) { // 检查是否已超过1秒
    // 执行操作
    timer.restart();
}

// 使用QTimeLine实现动画效果
QTimeLine *timeLine = new QTimeLine(1000, this); // 1秒动画
connect(timeLine, &QTimeLine::frameChanged, this, &MyClass::updateAnimation);
timeLine->start();