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 事件，放入事件队列中。
作者：dbzhang800
