QChronoTimer Class

Detaillierte Beschreibung

Die Klasse QChronoTimer bietet eine High-Level-Programmierschnittstelle für Timer. Um sie zu verwenden, erstellen Sie einen QChronoTimer, indem Sie entweder das Intervall an den Konstruktor übergeben oder es nach der Konstruktion mit setInterval() einstellen, sein timeout()-Signal mit den entsprechenden Slots verbinden und start() aufrufen. Von da an wird das Signal timeout() in konstanten Abständen ausgegeben. Ein Beispiel:

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

Sie können einen Timer so einstellen, dass er nur einmal abläuft, indem Sie setSingleShot(true) aufrufen.

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

Als Sonderfall wird ein QChronoTimer mit einem Timeout von 0ns so schnell wie möglich ablaufen, obwohl die Reihenfolge zwischen Null-Timern und anderen Ereignisquellen nicht spezifiziert ist. Null-Timer können verwendet werden, um etwas Arbeit zu erledigen und gleichzeitig eine ansprechende Benutzeroberfläche zu bieten:

        // The default interval is 0ns
        QChronoTimer *timer = new QChronoTimer(this);
        connect(timer, &QChronoTimer::timeout, this, &MyWidget::processOneThing);
        timer->start();

Von da an wird processOneThing() wiederholt aufgerufen. Er sollte so geschrieben sein, dass er immer schnell zurückkehrt (zum Beispiel nach der Verarbeitung eines Datenelements), damit Qt Ereignisse an die Benutzeroberfläche liefern und den Timer stoppen kann, sobald er seine Arbeit erledigt hat. Dies ist die traditionelle Art, schwere Arbeit in GUI-Anwendungen zu implementieren, aber da Multithreading auf immer mehr Plattformen verfügbar wird, ist eine moderne Alternative, die schwere Arbeit in einem anderen Thread als dem GUI-(Haupt-)Thread auszuführen. Qt verfügt über die Klasse QThread, mit der dies erreicht werden kann.

Genauigkeit und Timer-Auflösung

Die Genauigkeit von Timern hängt vom zugrunde liegenden Betriebssystem und der Hardware ab. Die meisten Plattformen unterstützen die Abfrage von Nano-Sekunden-Präzision für Timer (z.B. libc's nanosleep), obwohl die Genauigkeit des Timers in vielen realen Situationen nicht dieser Auflösung entsprechen wird.

Sie können timer type setzen, um QChronoTimer mitzuteilen, welche Genauigkeit vom System angefordert werden soll.

Für Qt::PreciseTimer wird QChronoTimer versuchen, die Genauigkeit bei 1ns zu halten. Präzise Zeitgeber werden niemals früher als erwartet ablaufen.

Bei den Typen Qt::CoarseTimer und Qt::VeryCoarseTimer kann QChronoTimer innerhalb der für diese Typen geltenden Spannen früher als erwartet aufwachen:

• 5% des Intervalls für Qt::CoarseTimer
• 500ms für Qt::VeryCoarseTimer

Alle Timer-Typen können später als erwartet ablaufen, wenn das System ausgelastet ist oder nicht in der Lage ist, die geforderte Genauigkeit zu liefern. In einem solchen Fall von Timeout-Überschreitung gibt Qt timeout() nur einmal aus, auch wenn mehrere Timeouts abgelaufen sind, und setzt dann das ursprüngliche Intervall fort.

Alternativen zu QChronoTimer

QChronoTimer bietet eine Auflösung im Nanosekundenbereich und einen Bereich von ±292 Jahren (geringeres Risiko eines Integer-Überlaufs, wenn das Intervall länger als std::numeric_limits<int>::max() ist). Wenn Sie nur eine Millisekundenauflösung und einen Bereich von ±24 Tagen benötigen, können Sie weiterhin die klassische Klasse QTimer verwenden.

Eine andere Alternative ist die Neuimplementierung der Methode QObject::timerEvent() in Ihrer Klasse (die eine Unterklasse von QObject sein muss) und die Verwendung eines der folgenden Ansätze:

• Verwendung von QBasicTimer, einer leichtgewichtigen Value-Klasse, die eine Timer-ID umhüllt. Sie können den Timer mit QBasicTimer::start() starten und ihn mit QBasicTimer::stop() stoppen. Sie können das Ereignis in Ihrem reimplemneted timerEvent() behandeln.
• Eine einfachere Methode ist die direkte Manipulation der Timer-IDs. Um den Timer zu starten, rufen Sie QObject::startTimer() auf und speichern die zurückgegebene ID. Um den Timer zu stoppen, rufen Sie QObject::killTimer() auf. Sie können das Ereignis in Ihrem reimplementierten timerEvent() behandeln. Dieser Ansatz ist in der Regel mühsamer als die Verwendung von QBasicTimer.

Ein Nachteil der Verwendung von timerEvent() ist, dass einige High-Level-Funktionen, wie Single-Shot-Timer und Signale, nicht unterstützt werden.

Einige Betriebssysteme beschränken die Anzahl der Timer, die verwendet werden können; Qt tut sein Bestes, um diese Beschränkungen zu umgehen.