QChronoTimer Class

Ausführliche Beschreibung

Die Klasse `QChronoTimer` bietet eine hochrangige 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 Erstellung mit ` setInterval()` festlegen, verbinden Sie das Signal ` timeout()` mit den entsprechenden Slots und rufen Sie ` start()` auf. Von da an gibt er in konstanten Intervallen das Signal „ timeout()“ aus. Zum Beispiel:

        auto *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 ü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()“ auslöst. 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.

Als Sonderfall läuft ein QChronoTimer mit einem Timeout von ` 0ns ` so schnell wie möglich ab, wobei die Reihenfolge zwischen Null-Timern und anderen Ereignisquellen nicht spezifiziert ist. Null-Timer können verwendet werden, um bestimmte Aufgaben auszuführen und gleichzeitig eine reaktionsschnelle Benutzeroberfläche zu gewährleisten:

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

Von diesem Zeitpunkt an wird „ processOneThing() “ wiederholt aufgerufen. Die Funktion sollte so geschrieben sein, dass sie stets schnell zurückkehrt (beispielsweise nach der Verarbeitung eines Datenelements), damit Qt Ereignisse an die Benutzeroberfläche übermitteln und den Timer anhalten kann, sobald er seine gesamte Arbeit erledigt hat. Dies ist die traditionelle Methode zur Implementierung rechenintensiver Aufgaben in GUI-Anwendungen. Da Multithreading jedoch auf immer mehr Plattformen verfügbar wird, besteht eine moderne Alternative darin, die rechenintensiven Aufgaben 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 Auflösung von Timern

Die Genauigkeit von Timern hängt vom zugrunde liegenden Betriebssystem und der Hardware ab. Die meisten Plattformen unterstützen die Anforderung einer Nanosekunden-Genauigkeit für Timer (zum Beispiel die Funktion ` nanosleep` der libc), auch wenn die Genauigkeit des Timers in vielen realen Situationen nicht dieser Auflösung entspricht.

Sie können die Option ` timer type ` festlegen, um QChronoTimer mitzuteilen, welche Genauigkeit vom System angefordert werden soll.

Bei der Einstellung „ Qt::PreciseTimer “ versucht QChronoTimer, die Genauigkeit auf „ 1ns “ zu halten. Präzise Timer laufen niemals früher als erwartet ab.

Bei den Typen „ Qt::CoarseTimer “ und „ Qt::VeryCoarseTimer “ kann QChronoTimer innerhalb der für diese Typen geltenden Toleranzen früher als erwartet aktiv werden:

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

Alle Timer-Typen können später als erwartet ablaufen, wenn das System ausgelastet ist oder die angeforderte Genauigkeit nicht gewährleisten kann. In einem solchen Fall einer Zeitüberschreitung löst Qt „ timeout()“ nur einmal aus, selbst wenn mehrere Zeitlimits 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 Ganzzahlüberlaufs, wenn das Intervall länger als ` std::numeric_limits<int>::max()` ist). Wenn Sie lediglich eine Auflösung im Millisekundenbereich und einen Bereich von ±24 Tagen benötigen, können Sie weiterhin die klassische Klasse ` QTimer ` verwenden

Eine weitere Alternative besteht darin, die Methode ` QObject::timerEvent()` in Ihrer Klasse (die eine Unterklasse von ` QObject` sein muss) neu zu implementieren und einen der folgenden Ansätze zu verwenden:

• Verwenden Sie ` QBasicTimer`, eine schlanke Wertklasse, die eine Timer-ID umschließt. Sie können den Timer mit ` QBasicTimer::start()` starten und mit ` QBasicTimer::stop()` stoppen. Das Ereignis können Sie in Ihrer neu implementierten Methode ` timerEvent()` verarbeiten.
• Eine eher low-level Methode ist die direkte Bearbeitung der Timer-IDs. Um den Timer zu starten, rufen Sie ` QObject::startTimer()` auf und speichern Sie die zurückgegebene ID. Um den Timer zu stoppen, rufen Sie ` QObject::killTimer()` auf. Sie können das Ereignis in Ihrer neu implementierten Methode ` timerEvent()` verarbeiten. Dieser Ansatz ist in der Regel umständlicher als die Verwendung von ` QBasicTimer`.

Ein Nachteil der Verwendung von ` timerEvent()` ist, dass einige hochrangige Funktionen, wie z. B. Einmal-Timer und Signale, nicht unterstützt werden.

Einige Betriebssysteme begrenzen die Anzahl der Timer, die verwendet werden dürfen; Qt versucht, diese Einschränkungen so gut wie möglich zu umgehen.