Temporizadores

QObjectla clase base de todos los objetos Qt, proporciona el soporte básico de temporizadores en Qt. Con QObject::startTimer(), se inicia un temporizador con un intervalo en milisegundos como argumento. La función devuelve un único ID integral del temporizador. El temporizador se disparará a intervalos regulares hasta que llame explícitamente a QObject::killTimer() con ese ID de temporizador.

En lugar de manejar IDs de temporizador directamente, puede utilizar QBasicTimer. QBasicTimer es una clase de valor, envoltura RAII alrededor de un ID de temporizador. El temporizador se inicia con QBasicTimer::start(), y se detiene con QBasicTimer::stop() (este último también se llama cuando se destruye). Para usar QBasicTimer, debes reimplementar timerEvent() en tu clase (que debe ser una subclase de QObject), y manejar el evento del temporizador allí.

Para que este mecanismo funcione, la aplicación debe ejecutarse en un bucle de eventos. Puedes iniciar un bucle de eventos con QApplication::exec(). Cuando un temporizador se dispara, la aplicación envía un QTimerEvent, y el flujo de control abandona el bucle de eventos hasta que el evento del temporizador es procesado. Esto implica que un temporizador no puede dispararse mientras tu aplicación está ocupada haciendo otra cosa. En otras palabras: la precisión de los temporizadores depende de la granularidad de tu aplicación.

En aplicaciones multihilo, puedes utilizar el mecanismo del temporizador en cualquier hilo que tenga un bucle de eventos. Para iniciar un bucle de eventos desde un hilo que no sea GUI, utiliza QThread::exec(). Qt utiliza el thread affinity del objeto para determinar qué subproceso entregará el QTimerEvent. Debido a esto, debes iniciar y detener todos los temporizadores en el subproceso del objeto; no es posible iniciar temporizadores para objetos en otro subproceso.

La API principal para la funcionalidad del temporizador es QTimer. QTimer almacena el intervalo en un entero con signo, lo que limita el intervalo máximo que soporta al número de milisegundos que pueden caber en un entero con signo (en la práctica, esto es un período de alrededor de 24 días).

Qt 6.8 introdujo la clase QChronoTimer. La principal diferencia entre las dos clases es que QChronoTimer soporta un intervalo mayor y una mayor precisión (std::chrono::nanoseconds). Para QTimer el intervalo máximo soportado es de ±24 días, mientras que para QChronoTimer es de ±292 años. Si sólo necesita una resolución de milisegundos y un intervalo de ±24 días, puede seguir utilizando QTimer. Tenga en cuenta que QChronoTimer existe principalmente porque la precisión de QTimer no podía cambiarse a std::chrono::nanoseconds sin romper la compatibilidad binaria.

La precisión de los temporizadores depende del sistema operativo subyacente. Windows 2000 tiene una precisión de 15ms; otros sistemas que hemos probado pueden manejar intervalos de 1ms.

QTimer proporciona temporizadores regulares que emiten una señal cuando el temporizador se dispara, y hereda de QObject para que encaje bien en la estructura de propiedad de la mayoría de los programas Qt. La forma normal de utilizarlo es la siguiente:

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

El objeto QTimer se hace hijo del objeto this para que, cuando se destruya this, se destruya también el temporizador. A continuación, la señal timeout() se conecta a la ranura que hará el trabajo, el intervalo del temporizador puede pasarse al constructor, o establecerse posteriormente con setInterval().

QTimer también proporciona funciones estáticas para temporizadores de disparo único. Por ejemplo

        MyWidget widget;
        QTimer::singleShot(200ms, &widget, &MyWidget::updateCaption);

200ms después de que se ejecute esta línea de código, se llamará al intervalo updateCaption().

Para que QTimer funcione, debes tener un bucle de eventos en tu aplicación; es decir, debes llamar a QCoreApplication::exec() en algún lugar. Los eventos del temporizador se entregarán sólo mientras el bucle de eventos se esté ejecutando.

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

El ejemplo del reloj analógico muestra cómo utilizar QTimer para redibujar un widget a intervalos regulares. De la implementación de AnalogClock

AnalogClock::AnalogClock(QWidget *parent)
    : QWidget(parent)
{
    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, QOverload<>::of(&AnalogClock::update));
    timer->start(1000);

    setWindowTitle(tr("Analog Clock"));
    resize(200, 200);
}

Cada segundo, QTimer llamará a la ranura QWidget::update() para refrescar la pantalla del reloj.