Thread Support in Qt

The most important class is QThread; this provides the means to start a new thread, which begins execution in your reimplementation of QThread::run(). This is similar to the Java thread class.

In order to write threaded programs it is necessary to protect access to data that two threads wish to access at once. Therefore there is also a QMutex class; a thread can lock the mutex, and while it has it locked no other thread can lock the mutex; an attempt to do so will block the other thread until the mutex is released. For example:

    class MyClass
    {
    public:
        void doStuff( int );

    private:
        QMutex mutex;
        int a;
        int b;
    };

    // This sets a to c, and b to c*2

    void MyClass::doStuff( int c )
    {
        mutex.lock();
        a = c;
        b = c * 2;
        mutex.unlock();
    } 

This ensures that only one thread at a time can be in MyClass::doStuff(), so b will always be equal to c * 2.

Also necessary is a method for threads to wait for another thread to wake it up given a condition; the QWaitCondition class provides this. Threads wait for the QWaitCondition to indicate that something has happened, blocking until it does. When something happens, QWaitCondition can wake up all of the threads waiting for that event or one randomly selected thread. (This is the same functionality as a POSIX Threads condition variable and is implemented as one on Unix.) For example:

    #include <qapplication.h>
    #include <qpushbutton.h>

    // global condition variable
    QWaitCondition mycond;

    // Worker class implementation
    class Worker : public QPushButton, public QThread
    {
        Q_OBJECT

    public:
        Worker(QWidget *parent = 0, const char *name = 0)
            : QPushButton(parent, name)
        {
            setText("Start Working");

            // connect the clicked() signal inherited from QPushButton to our
            // slotClicked() method
            connect(this, SIGNAL(clicked()), SLOT(slotClicked()));

            // call the start() method inherited from QThread... this starts
            // execution of the thread immediately
            QThread::start();
        }

    public slots:
        void slotClicked()
        {
            // wake up one thread waiting on this condition variable
            mycond.wakeOne();
        }

    protected:
        void run()
        {
            // this method is called by the newly created thread...

            for ( ;; ) {
                // lock the application mutex, and set the caption of
                // the window to indicate that we are waiting to
                // start working
                qApp->lock();
                setCaption( "Waiting..." );
                qApp->unlock();

                // wait until we are told to continue
                mycond.wait();

                // if we get here, we have been woken by another
                // thread... let's set the caption to indicate
                // that we are working
                qApp->lock();
                setCaption( "Working!" );
                qApp->unlock();

                // this could take a few seconds, minutes, hours, etc.
                // since it is in a separate thread from the GUI thread
                // the gui will not stop processing events...
                do_complicated_thing();
            }
        }
    };

    // main thread - all GUI events are handled by this thread.
    int main( int argc, char **argv )
    {
        QApplication app( argc, argv );

        // create a worker... the worker will run a thread when we do
        Worker firstworker( 0, "worker" );

        app.setMainWidget( &worker );
        worker.show();

        return app.exec();
    }
  

This program will wake up the worker thread whenever you press the button; the thread will go off and do some work and then go back to waiting to be told to do some more work. If the worker thread is already working when the button is pressed, nothing will happen. When the thread finishes working and calls QWaitCondition::wait() again, then it can be started.

Thread-safe posting of events

    QWidget *mywidget;
    QThread::postEvent( mywidget, new QPaintEvent( QRect(0, 0, 100, 100) ) );
  

  QApplication *qApp;
  QWidget *mywidget;

  qApp->lock();

  mywidget->setGeometry(0,0,100,100);

  QPainter p;
  p.begin(mywidget);
  p.drawLine(0,0,100,100);
  p.end();

  qApp->unlock();