QTimer源码分析(以Windows下实现为例)

起源

在newsmth上看到这样一个问题:

发信人: hgoldfish (老鱼), 信区: KDE_Qt
标  题: QTimer::singleShot()的疑问
发信站: 水木社区 (Mon Apr 11 22:03:48 2011), 站内

singleShot(0, ...)是表示下面的哪种情况呢?
1. 退出当前函数,回到事件循环的时候立即执行,忽略其它消息。
2. 把对应的QTimerEvent放到消息队列的最后,然后依次处理消息。
3. 把这个这个singleShot对应的QTimerEvent放到最后。依次处理消息。但是如果有新的消息到达时,它们会排到QTimerEvent的前面。

其中,2是假定消息队列没有优先级。1、3假定消息队列有优先级,但是1假定QTimerEvent最优先,而3假定QTimerEvent最不优先。

看文档似乎是3?

似乎挺有意思,于是,打开Qt的源码,慢慢看看,于是整理出本文。如果理解没问题的话,应该可以得出这个结论:

  • 消息队列是有优先级的。但是对与timerEvent事件,没用到优先级(Qt::NormalEventPriority?)。

  • 对于间隔不为零的timer,调用系统提供的计时器,然后等待响应系统的计时器事件
  • 对于间隔为零的timer,Qt自己进行了特殊处理。
    • 当使用静态函数QTimer::singleShot时,实际上直接调用了QueuedConnection方式的 QMetaObject::invokeMethod()

    • 当启动间隔为零的QTimer时,实际上先postEvent()派发了一个 QZeroTimerEvent到QAbstractEventDiapatch自身。在该事件的处理中,再通过sendEvent() 派发 QTimerEvent事件到对象中

一段废话,作为正文引子

每当需要一个计时器时,我们很容易想到QTimer,

  • 创建QTimer对象
  • 连接它的信号到我们的槽函数。

如果看Qt的Manual,我们还会注意到QBasicTimer和QTimeLine这两个类,也可起到计时的作用。那么这些之间那个最为根本呢?

所有这些都归结到QObject的3个成员函数中:

  • 在派生类中覆盖timerEvent()函数,进行处理
  • 通过startTimer()开启计时器
  • 通过killTimer() 结束

下面我们看看QTimer的计时事件是如何一步一步和系统提供的计时器(优先使用多媒体计时器,其次是普通的计时器)联系起来的

QTimer

看一下QTimer的源码,一切都明了了:

class QTimer:public QObject
{
...
public Q_SLOTS:
    void start(int msec);
    void start();
    void stop();
Q_SIGNALS:
    void timeout();
protected:
    void timerEvent(QTimerEvent *);
...
};

大家应该想得到了(就不贴代码了):

  • start() 调用 QObject::startTimer()
  • stop() 调用 QObject::killTimer()
  • timerEvent() 中发射信号 timeout()

QTimer::singleShot()

这是一个static成员函数,由于只需要一次事件。它其实没有创建QTimer对象,而是使用了一个QSingleShotTimer对象。这个类完整定义很简单

class QSingleShotTimer : public QObject
{
    Q_OBJECT
    int timerId;
public:
    ~QSingleShotTimer();
    QSingleShotTimer(int msec, QObject *r, const char * m);
Q_SIGNALS:
    void timeout();
protected:
    void timerEvent(QTimerEvent *);
};

这个没什么什么可介绍的,如果说特点的话,也就是 timerEvent 被调用一次后,就会将自己这个对象删除(呵呵,有点废话哈,调用一次使命就完成了呗)

另外呢,对于时间间隔为0的事件,甚至连QSingleShotTimer都不需要创建,而是直接用invokeMethod去调用相应的slot

void QTimer::singleShot(int msec, QObject *receiver, const char *member)
{
    if (receiver && member) {
        if (msec == 0) {
            // special code shortpath for 0-timers
            const char* bracketPosition = strchr(member, '(');
            if (!bracketPosition || !(member[0] >= '0' && member[0] <= '3')) {
                qWarning("QTimer::singleShot: Invalid slot specification");
                return;
            }
            QByteArray methodName(member+1, bracketPosition - 1 - member); // extract method name
            QMetaObject::invokeMethod(receiver, methodName.constData(), Qt::QueuedConnection);
            return;
        }
        (void) new QSingleShotTimer(msec, receiver, member);
    }
}

在 QMetaObject::invokeMethod的分析中,我们知道:对于QueuedConnection的连接,它最终通过QCoreApplication的postEvent() 函数派发了一个 QMetaCallEvent 事件。

QObject

  • 回归正题,看QObject的 startTimer和killTimer做了什么:

 

int QObject::startTimer(int interval)
{
    Q_D(QObject);
    d->pendTimer = true;                                // set timer flag
    return d->threadData->eventDispatcher->registerTimer(interval, this);
}
void QObject::killTimer(int id)
{
    Q_D(QObject);
    if (d->threadData->eventDispatcher)
        d->threadData->eventDispatcher->unregisterTimer(id);
}

代码倒是挺短,只是负担一下子交给eventDispatcher了。

QAbstractEventDispatcher

我们以windows下的情况为例看看吧:

void QEventDispatcherWin32::registerTimer(int timerId, int interval, QObject *object)
{
    Q_D(QEventDispatcherWin32);

    register WinTimerInfo *t = new WinTimerInfo;
    t->dispatcher = this;
    t->timerId  = timerId;
    t->interval = interval;
    t->obj  = object;
    t->inTimerEvent = false;
    t->fastTimerId = 0;

    if (d->internalHwnd)
        d->registerTimer(t);

    d->timerVec.append(t);                      // store in timer vector
    d->timerDict.insert(t->timerId, t);          // store timers in dict
}
bool QEventDispatcherWin32::unregisterTimer(int timerId)
{
    Q_D(QEventDispatcherWin32);
    WinTimerInfo *t = d->timerDict.value(timerId);
    d->timerDict.remove(t->timerId);
    d->timerVec.removeAll(t);
    d->unregisterTimer(t);
    return true;
}

进而,代码进入了 QEventDispatcherWin32Private

void QEventDispatcherWin32Private::registerTimer(WinTimerInfo *t)
{
    Q_Q(QEventDispatcherWin32);

    int ok = 0;
    if (t->interval > 20 || !t->interval || !qtimeSetEvent) {
        ok = 1;
        if (!t->interval)  // optimization for single-shot-zero-timer
            QCoreApplication::postEvent(q, new QZeroTimerEvent(t->timerId));
        else
            ok = SetTimer(internalHwnd, t->timerId, (uint) t->interval, 0);
    } else {
        ok = t->fastTimerId = qtimeSetEvent(t->interval, 1, qt_fast_timer_proc, (DWORD_PTR)t,
                                            TIME_CALLBACK_FUNCTION | TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
        if (ok == 0) { // fall back to normal timer if no more multimedia timers available
            ok = SetTimer(internalHwnd, t->timerId, (uint) t->interval, 0);
        }
    }
}
void QEventDispatcherWin32Private::unregisterTimer(WinTimerInfo *t, bool closingDown)
{
    // mark timer as unused
    if (!QObjectPrivate::get(t->obj)->inThreadChangeEvent && !closingDown)
        QAbstractEventDispatcherPrivate::releaseTimerId(t->timerId);

    if (t->interval == 0) {
        QCoreApplicationPrivate::removePostedTimerEvent(t->dispatcher, t->timerId);
    } else if (t->fastTimerId != 0) {
        qtimeKillEvent(t->fastTimerId);
        QCoreApplicationPrivate::removePostedTimerEvent(t->dispatcher, t->timerId);
    } else if (internalHwnd) {
        KillTimer(internalHwnd, t->timerId);
    }
    delete t;
}

呵呵,这段挺复杂的:

  • 对于时间间隔为0的timer,实际上并没有启动系统的计时器,而是创建了一个QZeroTimerEvent 事件
  • 对普通的timer,首先尝试启用多媒体定时器。若失败,则使用传统的SetTimer 和 KillTimer

非0的timer

我们先看看对正常的timer,系统如何通知程序定时事件的呢?熟悉Windows编程的应该对这个回调函数很熟悉吧(呵呵,我对windows编程不熟,说错了别怪我哈)

LRESULT QT_WIN_CALLBACK qt_internal_proc(HWND hwnd, UINT message, WPARAM wp, LPARAM lp)
{
if (message == WM_TIMER) {    
        Q_ASSERT(d != 0);
        d->sendTimerEvent(wp);
        return 0;
...
}

然后,看看这个sendTimerEvent做了什么

void QEventDispatcherWin32Private::sendTimerEvent(int timerId)
{
    WinTimerInfo *t = timerDict.value(timerId);
    if (t && !t->inTimerEvent) {
        // send event, but don't allow it to recurse
        t->inTimerEvent = true;

        QTimerEvent e(t->timerId);
        QCoreApplication::sendEvent(t->obj, &e);

        // timer could have been removed
        t = timerDict.value(timerId);
        if (t) {
            t->inTimerEvent = false;
        }
    }
}

挺简单的,就是通过QCoreApplication的sendEvent函数派发了QTimerEvent事件,剩下的工作当然就是Qt的事件系统的任务了。

间隔为0的timer

我们前面说了,对于间隔为0的timer,并没有启用系统的定时器,而是直接派发了一个QZeroTimerEvent 事件。我们知道,它进入事件系统以后,将会被派发到event函数

bool QEventDispatcherWin32::event(QEvent *e)
{
    Q_D(QEventDispatcherWin32);
    if (e->type() == QEvent::ZeroTimerEvent) {
        QZeroTimerEvent *zte = static_cast<QZeroTimerEvent*>(e);
        WinTimerInfo *t = d->timerDict.value(zte->timerId());
        if (t) {
            t->inTimerEvent = true;

            QTimerEvent te(zte->timerId());
            QCoreApplication::sendEvent(t->obj, &te);

            t = d->timerDict.value(zte->timerId());
            if (t) {
                if (t->interval == 0 && t->inTimerEvent) {
                    // post the next zero timer event as long as the timer was not restarted
                    QCoreApplication::postEvent(this, new QZeroTimerEvent(zte->timerId()));
                }

                t->inTimerEvent = false;
            }
        }
        return true;
    } else if (e->type() == QEvent::Timer) {
        QTimerEvent *te = static_cast<QTimerEvent*>(e);
        d->sendTimerEvent(te->timerId());
    }
    return QAbstractEventDispatcher::event(e);
}

看到对QZeroTimerEvent进行什么处理了吧?

  • 通过 QCoreApplication 的 sendEvent 派发出 QTimerEvent 事件
  • 同时 产生一个新的 QZeroTimerEvent 事件,放入事件队列中

 

你可能感兴趣的:(windows,timer,object,qt,callback,optimization)