Threading In Qt 4

Jul 31st, 10 / 0 Comments /

In this quick post we’ll take a look at Qt’s elegant and simple QFuture, QtConcurrentRun, and QFutureWatcher interfaces. Using these classes allows us to consume a QThreadPool thread for a specific function.

This is handy for many operations, and while simplistic in that we’re not synchronizing data, still has many uses, from processing large blocks of images to streaming chunks of data.

In this post we’ll check out some sample code for implementing QFuture.

Let’s start with the following code which implements QFuture in the most basic manner possible:

#include
  1. #include
  2. #include
  3. #include
  4. #include
  5.  
  6. int computation(int x){
  7.     long a,b,c;
  8.     a = 1; b = 1;
  9.     for(int i = 0; i < x; i++){
  10.         c = b + a;
  11.         a = b;
  12.         b = c;
  13.     }
  14.     return c;
  15. }
  16.  
  17. int main(int argc, char *argv[])
  18. {
  19.     QCoreApplication a(argc, argv);
  20.  
  21.     int x = 5;
  22.     QFuture future = QtConcurrent::run(computation, x);
  23.     // blocking…
  24.     future.waitForFinished();
  25.  
  26.     int result = future.result();
  27.     qDebug(QString::number(result).toStdString().c_str());
  28.  
  29.     return a.exec();
  30. }

This code will consume a thread for the computation method call, returning the result via future.result(). When compared to our raw POSIX thread example it becomes clear just how much more simple the Qt version is.

Simple enough, but this code has one potential problem: as the comment shows, waitForFinished() blocks, which means our GUI stalls.

To fix this we’ll implement a signal/slot solution to let the long-running process chug away in the background, leaving the GUI thread free for updates. Of course the only trick to this is we need signals and slots, which means we must break our application apart into traditional header and implementation files.

main.cpp

#include
  1. #include "mainwindow.h"
  2.  
  3. int main(int argc, char *argv[])
  4. {
  5.     QApplication a(argc, argv);
  6.     MainWindow w;
  7.     w.show();
  8.     return a.exec();
  9. }

mainwindow.cpp

#include “mainwindow.h”
  1. #include "thread.h"
  2.  
  3. MainWindow::MainWindow(QWidget *parent)
  4.     : QMainWindow(parent)
  5. {
  6.  
  7.     setWindowTitle("Threads Demo");
  8.  
  9.     startButton = new QPushButton("Start Thread…", this);
  10.     connect(startButton, SIGNAL(clicked()), this, SLOT(startButtonPushed()));
  11.  
  12.     QGridLayout *mainLayout = new QGridLayout;
  13.     mainLayout->addWidget(startButton);
  14.  
  15.     thread = new Thread(this);
  16.     connect(thread, SIGNAL(threadFinished(int)), this, SLOT(threadDone(int)));
  17.  
  18. }
  19.  
  20. MainWindow::~MainWindow()
  21. {
  22.  
  23. }
  24.  
  25. void MainWindow::startButtonPushed()
  26. {
  27.     // we pass a pointer to the object, the address of the method, and the arg
  28.     future = QtConcurrent::run(thread, &Thread::compute, 10);
  29. }
  30.  
  31. void MainWindow::threadDone(int x){
  32.     qDebug("threadDone");
  33.     qDebug(QString::number(x).toStdString().c_str());
  34. }

mainwindow.h

#ifndef MAINWINDOW_H
  1. #define MAINWINDOW_H
  2.  
  3. #include
  4. #include
  5. #include
  6.  
  7. #include
  8.  
  9. #include
  10. #include
  11. #include
  12.  
  13. #include "thread.h"
  14.  
  15. class MainWindow : public QMainWindow
  16. {
  17.     Q_OBJECT
  18.  
  19. public:
  20.     MainWindow(QWidget *parent = 0);
  21.     ~MainWindow();
  22.  
  23.     Thread *thread;
  24.     QFuture future;
  25.  
  26. public slots :
  27.     void startButtonPushed();
  28.     void threadDone(int);
  29.  
  30. signals :
  31.  
  32. private :
  33.     QPushButton *startButton;
  34. };
  35.  
  36. #endif // MAINWINDOW_H

thread.cpp

#include “thread.h”
  1.  
  2. Thread::Thread(QObject *parent) : QObject(parent) { }
  3.  
  4. Thread::~Thread() { }
  5.  
  6. void Thread::compute(int x){
  7.     long a,b,c;
  8.     a = 1; b = 1;
  9.     for(int i = 0; i < x; i++){
  10.         c = b + a;
  11.         a = b;
  12.         b = c;
  13.     }
  14.  
  15.     qlonglong h,j,u;
  16.     j = 1; u = 1;
  17.     for(int j = 0; j < 100000000; j++){
  18.         h = (u * j);
  19.         u = (h + 1) + j;
  20.  
  21.         for(int w = 0; w < 40000000; w++){
  22.             u = (j + 2) * 3;
  23.             j = (u + 2);
  24.             h = (u * 2);
  25.         }
  26.     }
  27.  
  28.     emit threadFinished(a);
  29. }

thread.h

#ifndef THREAD_H
  1. #define THREAD_H
  2.  
  3. #include
  4. #include
  5.  
  6. class Thread : public QObject
  7. {
  8.     Q_OBJECT
  9.  
  10. public :
  11.     Thread(QObject *parent = 0);
  12.     ~Thread();
  13.     void compute(int);
  14.  
  15. public slots :
  16.  
  17. signals :
  18.     void threadFinished(int);
  19.  
  20. };
  21.  
  22. #endif // THREAD_H

Between this and the official documentation it should be pretty clear what’s going on.

However. the one thing to point out is that time and again we’ll be confronted with the question of how do we ‘get’ values back from a signal/slot architecture. Of course in this example we’re using threads, but this question applies equally well to non-threaded scenarios.

In many instances the answer to this question is we needn’t do anything. We’re processing a batch of images and only need to know when the batch operation is complete. This can be in the form of a dialog box, and is where QFutureWatcher comes in–we only care about being notified as to when we’re done processing.

But that’s not always good enough, and is for me at least, where much of the learning pains of signal/slots has come from.

In this example I wanted to return the value of our threaded computation to the main thread via qDebug(). The problem was that while QFuture returns a value via future.result(), we cannot get this value asynchronously without blocking the GUI, as was the case in the first example. Why? Because when we implement QFutureWatcher to notify us the result of a QFuture has finished, we now only have signals, and these signals do not contain the results of our method call.

So how do we get our results?

In the end my solution was simple: bypass QFutureWatcher and emit a signal directly from the threaded computation method. This has the exact same effect as emitting a signal when the thread is done, only now we get a value back as well.

In the end my original failure was because I was trying to force functionality where it didn’t belong. QFuture is a very simple wrapper (though powerful), which makes spawning threads a snap. But it is in the end just that, a simplified wrapper for a more complex process.

Of course the downside to this is I had to implement my own signal/slot connections to retrieve the value, and in doing so, made my function a touch less portable. No matter, it’s a small price to pay as I now get my values back to the main thread as desired.

The last thing I would like to point out is the syntax of the call:

future = QtConcurrent::run(thread, &Thread::compute, 10);

Although this is covered in the official documentation I ended up stuck for a bit because I didn’t realize one very important subtlety:

When passing members functions the first parameter must be a pointer to an instance of the class. It says as much in the docs–the trick is that the second parameter must then be the address of the member function being called.

If you leave this part out you’ll get compiler errors, so make sure to double check what you’re passing.

Of course this is the most simplistic thread concept in Qt, but it’s a a darn powerful one. Study the code above, try it yourself, and get multi-threading!

C++, Qt
<< >>

Leave a Comment

* are Required fields