QChronoTimer Class

Descripción Detallada

La clase QChronoTimer proporciona una interfaz de programación de alto nivel para temporizadores. Para usarlo, crea un QChronoTimer, ya sea pasando el intervalo al constructor, o estableciéndolo después de la construcción usando setInterval(), conecta su señal timeout() a las ranuras apropiadas, y llama a start(). A partir de ese momento, emitirá la señal timeout() a intervalos constantes. Por ejemplo:

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

Puedes configurar un temporizador para que se agote sólo una vez llamando a setSingleShot(true).

En aplicaciones multihilo, puedes usar QChronoTimer en cualquier hilo que tenga un bucle de eventos. Para iniciar un bucle de eventos desde un hilo no-GUI, utilice QThread::exec(). Qt utiliza el thread affinity del temporizador para determinar qué subproceso emitirá la señal timeout(). Debido a esto, debes iniciar y detener el temporizador en su hilo; no es posible iniciar un temporizador desde otro hilo.

Como caso especial, un QChronoTimer con un tiempo de espera de 0ns expirará tan pronto como sea posible, aunque el orden entre temporizadores cero y otras fuentes de eventos no está especificado. Los temporizadores cero se pueden utilizar para hacer algo de trabajo mientras se sigue proporcionando una interfaz de usuario sensible:

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

A partir de entonces, processOneThing() será llamado repetidamente. Debería escribirse de tal manera que siempre retorne rápidamente (por ejemplo, después de procesar un dato) para que Qt pueda entregar eventos a la interfaz de usuario y detener el temporizador tan pronto como haya hecho todo su trabajo. Esta es la forma tradicional de implementar el trabajo pesado en las aplicaciones GUI, pero como el multithreading está cada vez disponible en más plataformas, una alternativa moderna es hacer el trabajo pesado en un hilo distinto del hilo (principal) de la GUI. Qt tiene la clase QThread, que puede utilizarse para conseguirlo.

Precisión y resolución del temporizador

La precisión de los temporizadores depende del sistema operativo subyacente y del hardware. La mayoría de las plataformas soportan solicitar precisión de nano-segundos para los temporizadores (por ejemplo, nanosleep de libc), aunque la precisión del temporizador no será igual a esta resolución en muchas situaciones del mundo real.

Puedes configurar timer type para indicar a QChronoTimer qué precisión debe solicitar al sistema.

Para Qt::PreciseTimer, QChronoTimer intentará mantener la precisión en 1ns. Los temporizadores precisos nunca expirarán antes de lo esperado.

Para los tipos Qt::CoarseTimer y Qt::VeryCoarseTimer, QChronoTimer puede despertar antes de lo esperado, dentro de los márgenes para esos tipos:

• 5% del intervalo para Qt::CoarseTimer
• 500ms para Qt::VeryCoarseTimer

Todos los tipos de temporizador pueden agotarse más tarde de lo esperado si el sistema está ocupado o no puede proporcionar la precisión solicitada. En tal caso de rebasamiento del tiempo de espera, Qt emitirá timeout() sólo una vez, aunque hayan expirado varios tiempos de espera, y luego reanudará el intervalo original.

Alternativas a QChronoTimer

QChronoTimer proporciona una resolución de nanosegundos y un rango de ±292 años (menos posibilidades de desbordamiento de enteros si el intervalo es mayor que std::numeric_limits<int>::max()). Si sólo necesita una resolución de milisegundos y un intervalo de ±24 días, puede seguir utilizando la clase clásica QTimer.

Otra alternativa es reimplementar el método QObject::timerEvent() en su clase (que debe ser una subclase de QObject), y utilizar uno de los siguientes enfoques:

• Usando QBasicTimer, una clase de valor ligero que envuelve un ID de temporizador. Puedes iniciar el temporizador con QBasicTimer::start() y detenerlo con QBasicTimer::stop(). Usted puede manejar el evento en su reimplemneted timerEvent().
• Un método de más bajo nivel es manipular los IDs del temporizador directamente. Para iniciar el temporizador llame a QObject::startTimer(), almacenando el ID devuelto. Para detener el temporizador llame a QObject::killTimer(). Puedes manejar el evento en tu reimplementación de timerEvent(). Este enfoque suele ser más engorroso que utilizar QBasicTimer.

Una desventaja de usar timerEvent() es que algunas características de alto nivel, como temporizadores de disparo único y señales, no están soportadas.

Algunos sistemas operativos limitan el número de temporizadores que se pueden utilizar; Qt hace todo lo posible para evitar estas limitaciones.