QChronoTimer Class

Description détaillée

La classe QChronoTimer fournit une interface de programmation de haut niveau pour les timers. Pour l'utiliser, créez un QChronoTimer, soit en passant l'intervalle au constructeur, soit en le fixant après la construction en utilisant setInterval(), connectez son signal timeout() aux slots appropriés, et appelez start(). À partir de ce moment, il émettra le signal timeout() à intervalles constants. Par exemple :

        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();

Vous pouvez configurer un timer pour qu'il ne se termine qu'une seule fois en appelant setSingleShot(true).

Dans les applications multithread, vous pouvez utiliser QChronoTimer dans n'importe quel thread qui a une boucle d'événement. Pour démarrer une boucle d'événements à partir d'un thread non-GUI, utilisez QThread::exec(). Qt utilise le thread affinity du timer pour déterminer quel thread émettra le signal timeout(). Pour cette raison, vous devez démarrer et arrêter la minuterie dans son propre thread ; il n'est pas possible de démarrer une minuterie à partir d'un autre thread.

Dans un cas particulier, un QChronoTimer avec un timeout de 0ns s'arrêtera dès que possible, bien que l'ordre entre les timers zéro et les autres sources d'événements ne soit pas spécifié. Les minuteurs zéro peuvent être utilisés pour effectuer un certain travail tout en fournissant une interface utilisateur réactive :

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

À partir de ce moment, processOneThing() sera appelé à plusieurs reprises. Il doit être écrit de manière à ce qu'il revienne toujours rapidement (par exemple, après avoir traité un élément de données) afin que Qt Quick puisse fournir des événements à l'interface utilisateur et arrêter le minuteur dès qu'il a fait tout son travail. C'est la manière traditionnelle de mettre en œuvre les tâches lourdes dans les applications d'interface graphique, mais comme le multithreading devient disponible sur de plus en plus de plateformes, une alternative moderne consiste à effectuer les tâches lourdes dans un thread autre que le thread (principal) de l'interface graphique. Qt dispose de la classe QThread, qui peut être utilisée à cette fin.

Précision et résolution de la minuterie

La précision des temporisateurs dépend du système d'exploitation et du matériel sous-jacents. La plupart des plates-formes peuvent demander une précision de l'ordre de la nano-seconde pour les minuteries (par exemple, nanosleep de la libc), bien que la précision de la minuterie ne corresponde pas à cette résolution dans de nombreuses situations réelles.

Vous pouvez définir timer type pour indiquer à QChronoTimer quelle précision demander au système.

Pour Qt::PreciseTimer, QChronoTimer essaiera de maintenir la précision à 1ns. Les minuteries précises ne s'arrêteront jamais plus tôt que prévu.

Pour les types Qt::CoarseTimer et Qt::VeryCoarseTimer, QChronoTimer peut se réveiller plus tôt que prévu, dans les marges prévues pour ces types :

• 5% de l'intervalle pour Qt::CoarseTimer
• 500ms pour Qt::VeryCoarseTimer

Tous les types de timer peuvent se terminer plus tard que prévu si le système est occupé ou incapable de fournir la précision demandée. Dans un tel cas de dépassement de délai, Qt XML n'émettra timeout() qu'une seule fois, même si plusieurs délais ont expiré, et reprendra ensuite l'intervalle original.

Alternatives à QChronoTimer

QChronoTimer offre une résolution de l'ordre de la nanoseconde et une plage de ±292 ans (moins de risques de débordement d'entier si l'intervalle est plus long que std::numeric_limits<int>::max()). Si vous n'avez besoin que d'une résolution en millisecondes et d'une plage de ±24 jours, vous pouvez continuer à utiliser la classe classique QTimer.

Une autre solution consiste à réimplémenter la méthode QObject::timerEvent() dans votre classe (qui doit être une sous-classe de QObject) et à utiliser l'une des approches suivantes :

• Utilisation de QBasicTimer, une classe de valeur légère contenant un ID de minuterie. Vous pouvez démarrer la minuterie avec QBasicTimer::start() et l'arrêter avec QBasicTimer::stop(). Vous pouvez gérer l'événement dans votre version réimplémentée de timerEvent().
• Une méthode de plus bas niveau consiste à manipuler directement les ID de la minuterie. Pour démarrer la minuterie, appelez QObject::startTimer(), en stockant l'ID renvoyée. Pour arrêter la minuterie, appelez QObject::killTimer(). Vous pouvez gérer l'événement dans votre version réimplémentée de timerEvent(). Cette approche est généralement plus lourde que l'utilisation de QBasicTimer.

L'utilisation de timerEvent() présente l'inconvénient de ne pas prendre en charge certaines fonctionnalités de haut niveau, telles que les minuteries et les signaux à action unique.

Certains systèmes d'exploitation limitent le nombre de temporisateurs qui peuvent être utilisés ; Qt fait de son mieux pour contourner ces limitations.