Timer

QObject, die Basisklasse aller Qt-Objekte, bietet die grundlegende Timer-Unterstützung in Qt. Mit ` QObject::startTimer()` starten Sie einen Timer mit einem Intervall in Millisekunden als Argument. Die Funktion gibt eine eindeutige ganzzahlige Timer-ID zurück. Der Timer wird dann in regelmäßigen Abständen ausgelöst, bis Sie ` QObject::killTimer()` explizit mit dieser Timer-ID aufrufen.

Anstatt Timer-IDs direkt zu verwalten, können Sie ` QBasicTimer` verwenden. ` QBasicTimer ` ist ein RAII-Wrapper vom Typ Wertklasse, der eine Timer-ID umschließt. Sie starten den Timer mit „ QBasicTimer::start “ () und stoppen ihn mit „ QBasicTimer::stop “ () (Letzteres wird auch bei der Zerstörung aufgerufen). Um „ QBasicTimer “ zu verwenden, müssen Sie „ timerEvent “ () in Ihrer Klasse neu implementieren (die eine Unterklasse von „ QObject “ sein muss) und dort das Timer-Ereignis verarbeiten.

Damit dieser Mechanismus funktioniert, muss die Anwendung in einer Ereignisschleife laufen. Sie können eine Ereignisschleife mit ` QCoreApplication::exec()` starten. Für Qt Widgets Anwendungen siehe ` QApplication::exec()`. Wenn ein Timer ausgelöst wird, sendet die Anwendung ein ` QTimerEvent`, und der Kontrollfluss verlässt die Ereignisschleife, bis das Timer-Ereignis verarbeitet ist. Dies bedeutet, dass ein Timer nicht ausgelöst werden kann, während Ihre Anwendung mit etwas anderem beschäftigt ist. Mit anderen Worten: Die Genauigkeit von Timern hängt von der Granularität Ihrer Anwendung ab. Die Genauigkeit von Timern hängt zudem vom zugrunde liegenden Betriebssystem und der Hardware ab. Kurze Intervalle können vom System-Scheduler gerundet oder verzögert werden, und alle Timer-Typen können später als angefordert ablaufen, wenn das System ausgelastet ist. Weitere Informationen zur Timer-Auflösung und zu „ Qt::TimerType “ finden Sie in der Dokumentation unter QTimer.

In Multithread-Anwendungen können Sie den Timer-Mechanismus in jedem Thread verwenden, der über eine Ereignisschleife verfügt. Um eine Ereignisschleife von einem Nicht-GUI-Thread aus zu starten, verwenden Sie ` QThread::exec()`. Qt verwendet die Eigenschaft „ thread affinity “ des Objekts, um zu bestimmen, welcher Thread die „ QTimerEvent “ auslöst. Aus diesem Grund müssen Sie alle Timer im Thread des Objekts starten und stoppen; es ist nicht möglich, Timer für Objekte in einem anderen Thread zu starten.

Die wichtigste API für die Timer-Funktionalität ist ` QTimer`. ` QTimer ` speichert das Intervall als vorzeichenbehaftete Ganzzahl, wodurch das maximal unterstützte Intervall auf die Anzahl der Millisekunden begrenzt ist, die in eine vorzeichenbehaftete Ganzzahl passen (in der Praxis entspricht dies einem Zeitraum von etwa 24 Tagen).

Mit Qt 6.8 wurde die Klasse ` QChronoTimer ` eingeführt. Der Hauptunterschied zwischen den beiden Klassen besteht darin, dass ` QChronoTimer ` einen größeren Intervallbereich und eine höhere Genauigkeit unterstützt (std::chrono::nanoseconds). Bei ` QTimer ` beträgt das maximal unterstützte Intervall ±24 Tage, bei ` QChronoTimer ` hingegen ±292 Jahre. Wenn Sie lediglich eine Auflösung im Millisekundenbereich und einen Bereich von ±24 Tagen benötigen, können Sie weiterhin QTimer verwenden. Beachten Sie, dass QChronoTimer hauptsächlich deshalb existiert, weil die Genauigkeit von QTimer nicht auf std::chrono::nanoseconds geändert werden konnte, ohne die Binärkompatibilität zu beeinträchtigen.

QTimer bietet reguläre Timer, die ein Signal ausgeben, wenn der Timer ausgelöst wird, und erbt von QObject, sodass es gut in die Eigentümerstruktur der meisten Qt-Programme passt. Die übliche Art der Verwendung sieht wie folgt aus:

        QTimer *timer = new QTimer(1s, this);
        connect(timer, &QTimer::timeout, this, &MyWidget::processOneThing);
        timer->start();
        auto *timer = new QTimer(this);
        connect(timer, &QTimer::timeout, this, &MyWidget::processOneThing);
        timer->setInterval(1s);
        timer->start();

Das ` QTimer `-Objekt wird zu einem untergeordneten Element des ` this `-Objekts gemacht, sodass der Timer ebenfalls zerstört wird, wenn ` this ` zerstört wird. Als Nächstes wird das Signal ` timeout()` mit dem Slot verbunden, der die Arbeit ausführt; das Timer-Intervall kann entweder an den Konstruktor übergeben oder später mit `setInterval()` festgelegt werden.

QTimer bietet zudem statische Funktionen für einmalig ausgelöste Timer. Zum Beispiel:

        MyWidget widget;
        QTimer::singleShot(200ms, &widget, &MyWidget::updateCaption);

200 ms nach Ausführung dieser Codezeile wird der Slot „ updateCaption() “ aufgerufen.

Damit ` QTimer ` funktioniert, muss Ihre Anwendung über eine Ereignisschleife verfügen; das heißt, Sie müssen an einer beliebigen Stelle ` QCoreApplication::exec()` aufrufen. Timer-Ereignisse werden nur dann ausgelöst, solange die Ereignisschleife läuft.

In Multithread-Anwendungen können Sie ` QTimer ` in jedem Thread verwenden, der über eine Ereignisschleife verfügt. Um eine Ereignisschleife von einem Nicht-GUI-Thread aus zu starten, verwenden Sie ` QThread::exec()`. Qt verwendet die Eigenschaft „ thread affinity “ des Timers, um zu bestimmen, welcher Thread das Signal „ timeout()“ aussendet. Aus diesem Grund müssen Sie den Timer in seinem eigenen Thread starten und stoppen; es ist nicht möglich, einen Timer von einem anderen Thread aus zu starten.

Das Beispiel „Analog Clock“ zeigt, wie man mit ` QTimer ` ein Widget in regelmäßigen Abständen neu zeichnet. Aus der Implementierung von ` AnalogClock`:

AnalogClock::AnalogClock(QWidget *parent)
    : QWidget(parent)
{
    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, QOverload<>::of(&AnalogClock::update));
    timer->start(1000);

    setWindowTitle(tr("Analog Clock"));
    resize(200, 200);
}

Jede Sekunde ruft „ QTimer “ den Slot „ QWidget::update()“ auf, um die Anzeige der Uhr zu aktualisieren.