QChronoTimer Class

Description détaillée

La classe QChronoTimer fournit une interface de programmation de haut niveau pour les minuteurs. Pour l’utiliser, créez un objet QChronoTimer, soit en passant l’intervalle au constructeur, soit en le définissant après la construction à l’aide de ` setInterval()`, connectez son signal ` timeout()` aux slots appropriés, puis appelez ` start()`. Dès lors, il émettra le signal timeout() à intervalles réguliers. 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 minuteur pour qu’il ne se déclenche qu’une seule fois en appelant ` setSingleShot(true)`.

Dans les applications multithread, vous pouvez utiliser QChronoTimer dans n’importe quel thread disposant d’une boucle d’événements. Pour démarrer une boucle d’événements à partir d’un thread non-GUI, utilisez QThread::exec(). Qt utilise l’ thread affinity du minuteur pour déterminer quel thread émettra le signal ` timeout()`. De ce fait, vous devez démarrer et arrêter le minuteur dans son propre thread ; il n’est pas possible de démarrer un minuteur à partir d’un autre thread.

Dans un cas particulier, un QChronoTimer dont le délai d’expiration est défini sur 0ns expirera dès que possible, bien que l’ordre d’exécution entre les « zero timers » et les autres sources d’événements ne soit pas spécifié. Les « zero timers » peuvent être utilisés pour effectuer certaines tâches tout en garantissant 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, la fonction ` processOneThing() ` sera appelée de manière répétée. Elle doit être écrite de telle sorte qu’elle renvoie toujours rapidement une valeur (par exemple, après le traitement d’un élément de données) afin que Qt puisse transmettre les événements à l’interface utilisateur et arrêter le minuteur dès qu’il a terminé tout son travail. Il s’agit de la méthode traditionnelle pour implémenter des tâches lourdes dans les applications GUI, mais comme le multithreading est désormais disponible sur un nombre croissant de plateformes, une alternative moderne consiste à exécuter ces tâches dans un thread autre que le thread de l’interface graphique (le thread principal). Qt dispose de la classe ` QThread `, qui peut être utilisée à cette fin.

Précision et résolution des temporisateurs

La précision des chronomètres dépend du système d’exploitation et du matériel sous-jacents. La plupart des plateformes prennent en charge la demande d’une précision à la nanoseconde pour les chronomètres (par exemple, la fonction ` nanosleep` de la bibliothèque libc), bien que la précision du chronomètre ne corresponde pas toujours à cette résolution dans de nombreuses situations réelles.

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

Pour la valeur Qt::PreciseTimer, QChronoTimer s’efforcera de maintenir la précision à 1ns. Les temporisateurs précis 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 limites de ces types :

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

Tous les types de temporisateurs peuvent expirer 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 l'expiration, Qt émettra timeout() une seule fois, même si plusieurs délais d'expiration ont expiré, puis reprendra l'intervalle d'origine.

Alternatives à QChronoTimer

QChronoTimer offre une résolution en nanosecondes 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 alternative 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 :

• Utiliser ` QBasicTimer`, une classe de valeur légère encapsulant un identifiant de minuteur. Vous pouvez démarrer le minuteur avec ` QBasicTimer::start()` et l’arrêter avec ` QBasicTimer::stop()`. Vous pouvez gérer l’événement dans votre méthode ` timerEvent()` réimplémentée.
• timerEventUne méthode plus basique consiste à manipuler directement les identifiants de minuteurs. Pour démarrer le minuteur, appelez ` QObject::startTimer()` et enregistrez l’identifiant renvoyé. Pour l’arrêter, appelez ` QObject::killTimer()`. Vous pouvez gérer l’événement dans votre méthode ` QBasicTimer()` réimplémentée. Cette approche est généralement plus fastidieuse que l’utilisation de ` `.

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

Certains systèmes d’exploitation limitent le nombre de temporisateurs pouvant être utilisés ; Qt s’efforce de contourner ces limitations.