Threading Basics

Example 3: Clock

We want to produce a clock application. The application has a GUI and a worker thread. The worker thread checks every 10 milliseconds what time it is. If the formatted time has changed, the result will be sent to the GUI thread where it is displayed.

Of course, this is an overly complicated way of designing a clock and, actually, a separate thread is unnecessary. We would be better off placing the timer in the main thread because the calculation made in the timer slot is very short-lived. This example is purely for instructional use and shows how to communicate from a worker thread to a GUI thread. Note that communication in this direction is easy. We only need to add a signal to QThread and make a queued signal/slot connection to the main thread. Communication from the GUI to the worker thread is shown in the next example.

 int main(int argc, char *argv[])
 {
     QApplication app(argc, argv);
     // build gui
     QWidget widget;
     QLabel *label = new QLabel;
     QHBoxLayout *layout = new QHBoxLayout(&widget);
     layout->addWidget(label);
     widget.setWindowTitle("clock");

     //instantiate thread object
     ClockThread clockThread;
     QObject::connect(&clockThread, SIGNAL(sendTime(QString)), label, SLOT(setText(QString)), Qt::QueuedConnection);
     clockThread.start();
     widget.show();
     app.exec();
     clockThread.quit();
     clockThread.wait();
     return 0;
 }

We've connected the clockThread with the label. The connection must be a queued signal-slot connection because we want to put the call in the event loop.

 // clock/clockthread.h
 class ClockThread : public QThread
 {
     Q_OBJECT
 signals:
     void sendTime(QString time);
 private:
     void run();
     QString m_lastTime;
 private slots:
     void timerHit();

 };

We have derived a class from QThread and declared the sendTime() signal.

 // clock/clockthread.cpp
 void ClockThread::run()
 {
     QTimer timer;
     connect(&timer, SIGNAL(timeout()), this, SLOT(timerHit()), Qt::DirectConnection);
     timer.setInterval(10);
     timer.start();   // puts one event in the threads event queue
     exec();
     timer.stop();
 }

 void ClockThread::timerHit()
 {
     QString newTime= QDateTime::currentDateTime().toString("ddd MMMM d yy, hh:mm:ss");
     if(m_lastTime != newTime ){
         m_lastTime = newTime;
         emit sendTime(newTime) ;
     }
 }

The trickiest part of this example is that the timer is connected to its slot via a direct connection. A default connection would produce a queued signal-slot connection because the connected objects live in different threads; remember that QThread does not live in the thread it creates.

Still it is safe to access ClockThread::timerHit() from the worker thread because ClockThread::timerHit() is private and only touches local variables and a private member that isn't touched by public methods. QDateTime::currentDateTime() isn't marked as thread-safe in Qt documentation, however we can get away with using it in this small example because we know that the QDateTime::currentDateTime() static method isn't used in any other threads.

 // movedobject/main.cpp
 int main(int argc, char *argv[])
 {
     QCoreApplication app(argc, argv);
     Thread thread;
     qDebug() << "main thread ID: " << app.thread()->currentThreadId();
     WorkerObject *worker = new WorkerObject;
     thread.launchWorker(worker);
     QMetaObject::invokeMethod(worker, "doWork", Qt::QueuedConnection);
     QMetaObject::invokeMethod(worker, "startPolling",  Qt::QueuedConnection,  Q_ARG(int, 500));
     //let application produce output for 3 seconds and quit
     QTimer::singleShot(3000, &app, SLOT(quit()));
     app.exec();
     thread.stop();
     thread.wait();
     delete worker;
     return 0;
 }